#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.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Threading;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using DoorBreach;
using DoorBreach.Functional;
using GameNetcodeStuff;
using HarmonyLib;
using LobbyCompatibility.Enums;
using LobbyCompatibility.Features;
using MalfunctioningDoors.Dependencies;
using MalfunctioningDoors.Functional;
using MalfunctioningDoors.Malfunctions;
using MalfunctioningDoors.Malfunctions.Impl;
using MalfunctioningDoors.Patches;
using Microsoft.CodeAnalysis;
using TestAccount666.MalfunctioningDoors.NetcodePatcher;
using Unity.Netcode;
using UnityEngine;
using UnityEngine.Events;
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.MalfunctioningDoors")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyDescription("Who needs working doors anyway?")]
[assembly: AssemblyFileVersion("1.14.0.0")]
[assembly: AssemblyInformationalVersion("1.14.0+ced8f910befae8fb046b368fb38dacdcd09efb5d")]
[assembly: AssemblyProduct("MalfunctioningDoors")]
[assembly: AssemblyTitle("TestAccount666.MalfunctioningDoors")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.14.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
[module: NetcodePatchedAssembly]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

		public NullableAttribute(byte P_0)
		{
			NullableFlags = new byte[1] { P_0 };
		}

		public NullableAttribute(byte[] P_0)
		{
			NullableFlags = P_0;
		}
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace MalfunctioningDoors
{
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency("TestAccount666.DoorBreach", "1.1.0")]
	[BepInPlugin("TestAccount666.MalfunctioningDoors", "MalfunctioningDoors", "1.14.0")]
	public class MalfunctioningDoors : BaseUnityPlugin
	{
		[CompilerGenerated]
		private sealed class <LoadAudioClips>d__20 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			private string <assemblyDirectory>5__1;

			private string <audioPath>5__2;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<assemblyDirectory>5__1 = null;
				<audioPath>5__2 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				if (<>1__state != 0)
				{
					return false;
				}
				<>1__state = -1;
				<assemblyDirectory>5__1 = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
				Logger.LogInfo((object)"Loading Sounds...");
				Debug.Assert(<assemblyDirectory>5__1 != null, "assemblyDirectory != null");
				<audioPath>5__2 = Path.Combine(<assemblyDirectory>5__1, "sounds");
				<audioPath>5__2 = (Directory.Exists(<audioPath>5__2) ? <audioPath>5__2 : Path.Combine(<assemblyDirectory>5__1));
				LoadGhostHandAudioClips(<audioPath>5__2);
				return false;
			}

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

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

		private const int GHOST_HAND_SOUNDS_SIZE = 3;

		internal static Object ghostHandPrefab = null;

		internal static readonly AudioClip[] GhostHandSfxList = (AudioClip[])(object)new AudioClip[3];

		public static MalfunctioningDoors Instance { get; private set; } = null;


		internal static ManualLogSource Logger { get; private set; } = null;


		internal static Harmony? Harmony { get; set; }

		private void Awake()
		{
			Logger = ((BaseUnityPlugin)this).Logger;
			Instance = this;
			if (DependencyChecker.IsLobbyCompatibilityInstalled())
			{
				Logger.LogInfo((object)"Found LobbyCompatibility Mod, initializing support :)");
				LobbyCompatibilitySupport.Initialize();
			}
			string directoryName = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
			Debug.Assert(directoryName != null, "modDirectory != null");
			AssetBundle val = AssetBundle.LoadFromFile(Path.Combine(directoryName, "ghosthand"));
			ghostHandPrefab = val.LoadAsset("ghosthand");
			Patch();
			DoorLockPatch.InitializeConfig(((BaseUnityPlugin)this).Config);
			MalfunctionalDoor.InitializeConfig(((BaseUnityPlugin)this).Config);
			FetchMalfunctions();
			Type[] types = Assembly.GetExecutingAssembly().GetTypes();
			Type[] array = types;
			foreach (Type type in array)
			{
				try
				{
					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);
						}
					}
				}
				catch (FileNotFoundException)
				{
				}
			}
			((MonoBehaviour)this).StartCoroutine(LoadAudioClips());
			Logger.LogInfo((object)"TestAccount666.MalfunctioningDoors v1.14.0 has loaded!");
		}

		internal static void Patch()
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Expected O, but got Unknown
			if (Harmony == null)
			{
				Harmony = new Harmony("TestAccount666.MalfunctioningDoors");
			}
			Logger.LogDebug((object)"Patching...");
			Harmony.PatchAll(typeof(DoorLockPatch));
			Harmony.PatchAll(typeof(RoundManagerPatch));
			Logger.LogDebug((object)"Finished patching!");
		}

		internal static void Unpatch()
		{
			Logger.LogDebug((object)"Unpatching...");
			Harmony? harmony = Harmony;
			if (harmony != null)
			{
				harmony.UnpatchSelf();
			}
			Logger.LogDebug((object)"Finished unpatching!");
		}

		private static void FetchMalfunctions()
		{
			MalfunctionGenerator.MalfunctionDictionary.Clear();
			Type[] types = Assembly.GetExecutingAssembly().GetTypes();
			IEnumerable<Type> enumerable = types.Where(Predicate);
			foreach (Type item in enumerable)
			{
				MalfunctionAttribute malfunctionAttribute = (MalfunctionAttribute)item.GetCustomAttribute(typeof(MalfunctionAttribute), inherit: false);
				int value = malfunctionAttribute.weight;
				MethodInfo method = item.GetMethod("OverrideWeight", BindingFlags.Static | BindingFlags.Public);
				if ((object)method != null)
				{
					value = (int)method.Invoke(null, new object[1] { ((BaseUnityPlugin)Instance).Config });
				}
				item.GetMethod("InitializeConfig", BindingFlags.Static | BindingFlags.Public)?.Invoke(null, new object[1] { ((BaseUnityPlugin)Instance).Config });
				MalfunctionGenerator.MalfunctionDictionary.Add(item, value);
			}
		}

		private static bool Predicate(ICustomAttributeProvider type)
		{
			return type.GetCustomAttributes(typeof(MalfunctionAttribute), inherit: false).Length != 0;
		}

		[IteratorStateMachine(typeof(<LoadAudioClips>d__20))]
		private static IEnumerator LoadAudioClips()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <LoadAudioClips>d__20(0);
		}

		private static void LoadGhostHandAudioClips(string audioPath)
		{
			Logger.LogInfo((object)"Loading Ghost Hand Sounds...");
			string text = Path.Combine(audioPath, "GhostHandSounds");
			text = (Directory.Exists(text) ? text : Path.Combine(audioPath));
			for (int i = 1; i <= 3; i++)
			{
				int num = i - 1;
				AudioClip val = LoadAudioClipFromFile(new Uri(Path.Combine(text, $"GhostHand{i}.wav")), $"GhostHand{i}");
				if (val == null)
				{
					Logger.LogInfo((object)$"Failed to load clip 'GhostHand{i}'!");
					continue;
				}
				GhostHandSfxList[num] = val;
				Logger.LogInfo((object)("Loaded clip '" + ((Object)val).name + "'!"));
			}
		}

		private static AudioClip? LoadAudioClipFromFile(Uri filePath, string name)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Invalid comparison between Unknown and I4
			UnityWebRequest audioClip = UnityWebRequestMultimedia.GetAudioClip(filePath, (AudioType)20);
			try
			{
				UnityWebRequestAsyncOperation val = audioClip.SendWebRequest();
				while (!((AsyncOperation)val).isDone)
				{
					Thread.Sleep(100);
				}
				if ((int)audioClip.result != 1)
				{
					Logger.LogError((object)("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 MyPluginInfo
	{
		public const string PLUGIN_GUID = "TestAccount666.MalfunctioningDoors";

		public const string PLUGIN_NAME = "MalfunctioningDoors";

		public const string PLUGIN_VERSION = "1.14.0";
	}
}
namespace MalfunctioningDoors.Patches
{
	[HarmonyPatch(typeof(DoorLock))]
	public static class DoorLockPatch
	{
		private static Random? _syncedRandom;

		private static int _malfunctioningDoorChance = 30;

		public static Random SyncedRandom
		{
			get
			{
				return _syncedRandom ?? (_syncedRandom = new Random());
			}
			set
			{
				_syncedRandom = value;
			}
		}

		public static void InitializeConfig(ConfigFile configFile)
		{
			_malfunctioningDoorChance = configFile.Bind<int>("1. General", "1. Malfunctional Door Chance", 30, "Defines the chance that a door can be malfunctional").Value;
		}

		[HarmonyPatch("Awake")]
		[HarmonyPostfix]
		[HarmonyAfter(new string[] { "TestAccount666.DoorBreach" })]
		public static void AfterAwake(DoorLock __instance)
		{
			Type malfunctionalDoorType = typeof(DormantMalfunction);
			if (SyncedRandom.Next(0, 100) < _malfunctioningDoorChance)
			{
				malfunctionalDoorType = MalfunctionGenerator.GenerateMalfunctionalDoor(SyncedRandom);
			}
			AddMalfunction(__instance, malfunctionalDoorType);
		}

		[HarmonyPatch("UnlockDoorSyncWithServer")]
		[HarmonyPostfix]
		public static void AfterUnlockDoorSyncWithServer(DoorLock __instance)
		{
			MalfunctionalDoor component = ((Component)__instance).gameObject.GetComponent<MalfunctionalDoor>();
			if (component != null && component.ShouldExecute())
			{
				component.UseKey();
			}
		}

		internal static void AddMalfunction(DoorLock? doorLock, Type malfunctionalDoorType)
		{
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Expected O, but got Unknown
			if (doorLock == null || !Object.op_Implicit((Object)(object)doorLock))
			{
				return;
			}
			if (!malfunctionalDoorType.IsSubclassOf(typeof(MalfunctionalDoor)))
			{
				throw new ArgumentException("Type '" + malfunctionalDoorType.FullName + "'");
			}
			MalfunctionalDoor malfunctionalDoor = (MalfunctionalDoor)(object)((Component)doorLock).gameObject.AddComponent(malfunctionalDoorType);
			((UnityEvent<PlayerControllerB>)(object)doorLock.doorTrigger.onInteract).AddListener((UnityAction<PlayerControllerB>)delegate(PlayerControllerB playerControllerB)
			{
				if (playerControllerB != null && malfunctionalDoor.ShouldExecute())
				{
					malfunctionalDoor.UseInteract(playerControllerB);
				}
			});
			InteractTrigger val = ((Component)doorLock).gameObject.AddComponent<InteractTrigger>();
			val.touchTrigger = true;
			val.interactable = true;
			val.onInteract = new InteractEvent();
			((UnityEvent<PlayerControllerB>)(object)val.onInteract).AddListener((UnityAction<PlayerControllerB>)delegate(PlayerControllerB playerControllerB)
			{
				if (playerControllerB != null && malfunctionalDoor.ShouldExecute())
				{
					malfunctionalDoor.TouchInteract(playerControllerB);
				}
			});
		}
	}
	[HarmonyPatch(typeof(RoundManager))]
	public static class RoundManagerPatch
	{
		[HarmonyPatch("GenerateNewLevelClientRpc")]
		[HarmonyPrefix]
		public static void BeforeGenerateNewLevelClientRpc(int randomSeed)
		{
			DoorLockPatch.SyncedRandom = new Random(randomSeed);
		}
	}
}
namespace MalfunctioningDoors.Malfunctions
{
	public abstract class MalfunctionalDoor : MonoBehaviour
	{
		[CompilerGenerated]
		private sealed class <RollChangeMalfunctionChance>d__13 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public MalfunctionalDoor <>4__this;

			private int <chance>5__1;

			private Type <malfunctionalDoor>5__2;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0052: Unknown result type (might be due to invalid IL or missing references)
				//IL_005c: Expected O, but got Unknown
				//IL_0037: Unknown result type (might be due to invalid IL or missing references)
				//IL_0041: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					goto IL_0104;
				case 1:
					<>1__state = -1;
					<>2__current = (object)new WaitForEndOfFrame();
					<>1__state = 2;
					return true;
				case 2:
					{
						<>1__state = -1;
						if (<>4__this._destroy)
						{
							break;
						}
						if (<>4__this.doorLock != null && Object.op_Implicit((Object)(object)<>4__this.doorLock))
						{
							<chance>5__1 = DoorLockPatch.SyncedRandom.Next(0, 100);
							if (<chance>5__1 <= _changeMalfunctionChance)
							{
								<malfunctionalDoor>5__2 = MalfunctionGenerator.GenerateMalfunctionalDoor(DoorLockPatch.SyncedRandom);
								DoorLockPatch.AddMalfunction(<>4__this.doorLock, <malfunctionalDoor>5__2);
								Object.Destroy((Object)(object)<>4__this);
								break;
							}
						}
						goto IL_0104;
					}
					IL_0104:
					<>2__current = (object)new WaitForSeconds(60f);
					<>1__state = 1;
					return true;
				}
				return false;
			}

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

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

		private static int _changeMalfunctionChance = 30;

		protected DoorLock? doorLock;

		private bool _destroy;

		private void Awake()
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Expected O, but got Unknown
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Expected O, but got Unknown
			EventHandler.doorBreach = (DoorBreachEvent)Delegate.Combine((Delegate?)(object)EventHandler.doorBreach, (Delegate?)new DoorBreachEvent(DestroyMalfunctions));
		}

		private void DestroyMalfunctions(DoorBreachEventArguments doorBreachEventArguments)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Expected O, but got Unknown
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Expected O, but got Unknown
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Invalid comparison between Unknown and I4
			EventHandler.doorBreach = (DoorBreachEvent)Delegate.Remove((Delegate?)(object)EventHandler.doorBreach, (Delegate?)new DoorBreachEvent(DestroyMalfunctions));
			if ((int)doorBreachEventArguments.doorBreachMode == 0)
			{
				return;
			}
			DoorLock? obj = doorLock;
			MalfunctionalDoor[] array = ((obj != null) ? ((Component)obj).GetComponents<MalfunctionalDoor>() : null);
			if (array == null)
			{
				array = Array.Empty<MalfunctionalDoor>();
			}
			MalfunctionalDoor[] array2 = array;
			foreach (MalfunctionalDoor malfunctionalDoor in array2)
			{
				if (malfunctionalDoor != null)
				{
					Object.Destroy((Object)(object)malfunctionalDoor);
				}
			}
		}

		private void Start()
		{
			((MonoBehaviour)this).StartCoroutine(RollChangeMalfunctionChance());
		}

		private void OnDestroy()
		{
			_destroy = true;
		}

		protected bool IsDestroyed()
		{
			return _destroy;
		}

		public abstract void TouchInteract(PlayerControllerB playerControllerB);

		public abstract void UseInteract(PlayerControllerB playerControllerB);

		public static void InitializeConfig(ConfigFile configFile)
		{
			_changeMalfunctionChance = configFile.Bind<int>("1. General", "2. Malfunction Change Chance", 30, "Defines the chance, if a malfunction is changed").Value;
		}

		public abstract void UseKey();

		public abstract bool ShouldExecute();

		[IteratorStateMachine(typeof(<RollChangeMalfunctionChance>d__13))]
		private IEnumerator RollChangeMalfunctionChance()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <RollChangeMalfunctionChance>d__13(0)
			{
				<>4__this = this
			};
		}
	}
	[AttributeUsage(AttributeTargets.Class)]
	public class MalfunctionAttribute : Attribute
	{
		internal readonly int weight;

		public MalfunctionAttribute(int weight = 1)
		{
			this.weight = weight;
			base..ctor();
		}
	}
	public class MalfunctionDictionary : Dictionary<Type, int>
	{
		public new void Add(Type key, int value)
		{
			if (!key.IsSubclassOf(typeof(MalfunctionalDoor)))
			{
				throw new InvalidOperationException("MalfunctionDictionary can only contain sub-types of " + typeof(MalfunctionalDoor).FullName + "!");
			}
			base.Add(key, value);
		}
	}
	public static class MalfunctionGenerator
	{
		public static readonly MalfunctionDictionary MalfunctionDictionary = new MalfunctionDictionary();

		public static Type GenerateMalfunctionalDoor(Random random)
		{
			int num = random.Next(1000, 9999);
			HashSet<KeyValuePair<Type, int>> hashSet = FisherYatesShuffle(MalfunctionDictionary, random).ToHashSet();
			while (num > 0)
			{
				foreach (KeyValuePair<Type, int> item in hashSet)
				{
					num -= item.Value;
					if (num > 0)
					{
						continue;
					}
					return item.Key;
				}
			}
			MalfunctioningDoors.Logger.LogError((object)"Couldn't find any malfunctional door type, falling back to CloseMalfunction as default!");
			return typeof(CloseMalfunction);
		}

		private static IEnumerable<KeyValuePair<TKey, TValue>> FisherYatesShuffle<TKey, TValue>(Dictionary<TKey, TValue> dictionary, Random random)
		{
			List<KeyValuePair<TKey, TValue>> list = dictionary.ToList();
			int num = list.Count;
			while (num > 1)
			{
				num--;
				int num2 = random.Next(num + 1);
				List<KeyValuePair<TKey, TValue>> list2 = list;
				int index = num2;
				int index2 = num;
				KeyValuePair<TKey, TValue> value = list[num];
				KeyValuePair<TKey, TValue> value2 = list[num2];
				list2[index] = value;
				list[index2] = value2;
			}
			return list;
		}
	}
}
namespace MalfunctioningDoors.Malfunctions.Impl
{
	[Malfunction(100)]
	public class CloseMalfunction : MalfunctionalDoor
	{
		[CompilerGenerated]
		private sealed class <DelayedTask>d__13 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public float delay;

			public Action action;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0032: Unknown result type (might be due to invalid IL or missing references)
				//IL_003c: Expected O, but got Unknown
				//IL_004d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0057: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitForSeconds(delay);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<>2__current = (object)new WaitForEndOfFrame();
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					action();
					return false;
				}
			}

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

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

		private static int _lockChance = 30;

		private static int _lockWhenCloseChance = 80;

		private static int _openCloseAfterTwoSecondsChance = 40;

		private static int _malfunctionChance = 20;

		private static Random SyncedRandom => DoorLockPatch.SyncedRandom;

		private void Start()
		{
			doorLock = ((Component)this).GetComponent<DoorLock>();
		}

		public static int OverrideWeight(ConfigFile configFile)
		{
			return configFile.Bind<int>("2. Close Malfunction", "1. Malfunction Weight", 100, "Defines the weight of a malfunction. The higher, the more likely it is to appear").Value;
		}

		public new static void InitializeConfig(ConfigFile configFile)
		{
			_malfunctionChance = configFile.Bind<int>("2. Close Malfunction", "2. Malfunction Chance", 20, "Defines the chance, if a malfunction is executed").Value;
			_lockChance = configFile.Bind<int>("2. Close Malfunction", "3. Lock Chance", 30, "Defines the chance, if a door will be locked").Value;
			_lockWhenCloseChance = configFile.Bind<int>("2. Close Malfunction", "4. Lock When Close Chance", 80, "Defines the chance, if a door will be locked after closing (The 'Lock Chance' will be rolled first)").Value;
			_openCloseAfterTwoSecondsChance = configFile.Bind<int>("2. Close Malfunction", "5. Open Close After Two Seconds Chance", 40, "Defines the chance, if a door will open/close after two seconds after being opened/closed ('Malfunction Chance' will be rolled first)").Value;
		}

		public override void TouchInteract(PlayerControllerB playerControllerB)
		{
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			if (doorLock == null || !Object.op_Implicit((Object)(object)doorLock) || !doorLock.isDoorOpened || ((Component)doorLock).GetComponent<WaitingForDoorToBeClosed>() != null)
			{
				return;
			}
			int num = SyncedRandom.Next(0, 100);
			if (num >= _lockChance)
			{
				return;
			}
			int num2 = SyncedRandom.Next(0, 100);
			if (num2 < _lockWhenCloseChance)
			{
				WaitingForDoorToBeClosed waitingForDoorToBeClosed = ((Component)doorLock).gameObject.AddComponent<WaitingForDoorToBeClosed>();
				((MonoBehaviour)waitingForDoorToBeClosed).StartCoroutine(WaitingForDoorToBeClosed.WaitForDoorToBeClosed(doorLock));
				return;
			}
			MalfunctioningDoors.Logger.LogInfo((object)"Locking door <:)");
			doorLock.LockDoor(30f);
			DoorLocker component = ((Component)doorLock).gameObject.GetComponent<DoorLocker>();
			if (component == null)
			{
				MalfunctioningDoors.Logger.LogFatal((object)"No DoorLocker found?!");
			}
			else
			{
				DoorBreach.DoorNetworkManager.LockDoorServerRpc(NetworkObjectReference.op_Implicit(((NetworkBehaviour)doorLock).NetworkObject));
			}
		}

		public override void UseInteract(PlayerControllerB playerControllerB)
		{
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			PlayerControllerB playerControllerB2 = playerControllerB;
			if (doorLock == null || !Object.op_Implicit((Object)(object)doorLock))
			{
				return;
			}
			int num = SyncedRandom.Next(0, 100);
			DoorLocker component = ((Component)doorLock).gameObject.GetComponent<DoorLocker>();
			if (component == null)
			{
				MalfunctioningDoors.Logger.LogFatal((object)"No DoorLocker found?!");
				return;
			}
			bool open = !doorLock.isDoorOpened;
			if (num >= _openCloseAfterTwoSecondsChance)
			{
				DoorBreach.DoorNetworkManager.SetDoorOpenServerRpc(NetworkObjectReference.op_Implicit(((NetworkBehaviour)doorLock).NetworkObject), (int)playerControllerB2.playerClientId, open);
				return;
			}
			((MonoBehaviour)this).StartCoroutine(DelayedTask(2f, delegate
			{
				//IL_002f: Unknown result type (might be due to invalid IL or missing references)
				if (doorLock.isDoorOpened)
				{
					DoorBreach.DoorNetworkManager.SetDoorOpenServerRpc(NetworkObjectReference.op_Implicit(((NetworkBehaviour)doorLock).NetworkObject), (int)playerControllerB2.playerClientId, open);
				}
			}));
		}

		public override void UseKey()
		{
		}

		public override bool ShouldExecute()
		{
			return SyncedRandom.Next(0, 100) < _malfunctionChance && !IsDestroyed();
		}

		[IteratorStateMachine(typeof(<DelayedTask>d__13))]
		private static IEnumerator DelayedTask(float delay, Action action)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <DelayedTask>d__13(0)
			{
				delay = delay,
				action = action
			};
		}
	}
	internal class WaitingForDoorToBeClosed : MonoBehaviour
	{
		[CompilerGenerated]
		private sealed class <WaitForDoorToBeClosed>d__2 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public DoorLock doorLock;

			private DoorLocker <doorLocker>5__1;

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

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

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

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

			private bool MoveNext()
			{
				//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
				//IL_0043: Unknown result type (might be due to invalid IL or missing references)
				//IL_004d: Expected O, but got Unknown
				//IL_006d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0077: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					MalfunctioningDoors.Logger.LogInfo((object)"Waiting for door to be closed :)");
					goto IL_005d;
				case 1:
					<>1__state = -1;
					goto IL_005d;
				case 2:
					{
						<>1__state = -1;
						MalfunctioningDoors.Logger.LogInfo((object)"Locking door <:)");
						doorLock.LockDoor(30f);
						<doorLocker>5__1 = ((Component)doorLock).gameObject.GetComponent<DoorLocker>();
						if (<doorLocker>5__1 == null)
						{
							MalfunctioningDoors.Logger.LogFatal((object)"No DoorLocker found?!");
							return false;
						}
						DoorBreach.DoorNetworkManager.LockDoorServerRpc(NetworkObjectReference.op_Implicit(((NetworkBehaviour)doorLock).NetworkObject));
						_done = true;
						return false;
					}
					IL_005d:
					if (doorLock.isDoorOpened)
					{
						<>2__current = (object)new WaitForSeconds(1f);
						<>1__state = 1;
						return true;
					}
					<>2__current = (object)new WaitForEndOfFrame();
					<>1__state = 2;
					return true;
				}
			}

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

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

		private static bool _done;

		private void Update()
		{
			if (_done)
			{
				_done = false;
				Object.Destroy((Object)(object)this);
			}
		}

		[IteratorStateMachine(typeof(<WaitForDoorToBeClosed>d__2))]
		internal static IEnumerator WaitForDoorToBeClosed(DoorLock doorLock)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <WaitForDoorToBeClosed>d__2(0)
			{
				doorLock = doorLock
			};
		}
	}
	[Malfunction(100)]
	public class DormantMalfunction : MalfunctionalDoor
	{
		public override void TouchInteract(PlayerControllerB playerControllerB)
		{
		}

		public override void UseInteract(PlayerControllerB playerControllerB)
		{
		}

		public override void UseKey()
		{
		}

		public override bool ShouldExecute()
		{
			return false;
		}
	}
	[Malfunction(65)]
	public class EatKeyMalfunction : MalfunctionalDoor
	{
		[CompilerGenerated]
		private sealed class <LockDoorRoutine>d__9 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public EatKeyMalfunction <>4__this;

			private DoorLocker <doorLocker>5__1;

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

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

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

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

			private bool MoveNext()
			{
				//IL_002c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0036: Expected O, but got Unknown
				//IL_0058: Unknown result type (might be due to invalid IL or missing references)
				//IL_0062: Expected O, but got Unknown
				//IL_0101: Unknown result type (might be due to invalid IL or missing references)
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitForEndOfFrame();
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<>2__current = (object)new WaitUntil((Func<bool>)(() => <>4__this.doorLock != null));
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					if (<>4__this.doorLock == null || !Object.op_Implicit((Object)(object)<>4__this.doorLock))
					{
						return false;
					}
					<>4__this.doorLock.LockDoor(30f);
					<doorLocker>5__1 = ((Component)<>4__this.doorLock).gameObject.GetComponent<DoorLocker>();
					if (<doorLocker>5__1 == null)
					{
						MalfunctioningDoors.Logger.LogFatal((object)"No DoorLocker found?!");
						return false;
					}
					DoorBreach.DoorNetworkManager.LockDoorServerRpc(NetworkObjectReference.op_Implicit(((NetworkBehaviour)<>4__this.doorLock).NetworkObject));
					return false;
				}
			}

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

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

		private static int _malfunctionChance = 65;

		private static Random SyncedRandom => DoorLockPatch.SyncedRandom;

		private void Start()
		{
			doorLock = ((Component)this).GetComponent<DoorLock>();
			((MonoBehaviour)this).StartCoroutine(LockDoorRoutine());
		}

		public static int OverrideWeight(ConfigFile configFile)
		{
			return configFile.Bind<int>("3. Eat Key Malfunction", "1. Malfunction Weight", 65, "Defines the weight of a malfunction. The higher, the more likely it is to appear").Value;
		}

		public new static void InitializeConfig(ConfigFile configFile)
		{
			_malfunctionChance = configFile.Bind<int>("3. Eat Key Malfunction", "2. Malfunction Chance", 65, "Defines the chance, if a malfunction is executed").Value;
		}

		public override void TouchInteract(PlayerControllerB playerControllerB)
		{
		}

		public override void UseInteract(PlayerControllerB playerControllerB)
		{
		}

		public override void UseKey()
		{
			((MonoBehaviour)this).StartCoroutine(LockDoorRoutine());
		}

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

		public override bool ShouldExecute()
		{
			return SyncedRandom.Next(0, 100) < _malfunctionChance && !IsDestroyed();
		}
	}
	[Malfunction(75)]
	public class GhostHandMalfunction : MalfunctionalDoor
	{
		private static int _malfunctionChance = 86;

		private static Random SyncedRandom => DoorLockPatch.SyncedRandom;

		private void Start()
		{
			doorLock = ((Component)this).GetComponent<DoorLock>();
		}

		public static int OverrideWeight(ConfigFile configFile)
		{
			return configFile.Bind<int>("4. Ghost Hand Malfunction", "1. Malfunction Weight", 75, "Defines the weight of a malfunction. The higher, the more likely it is to appear").Value;
		}

		public new static void InitializeConfig(ConfigFile configFile)
		{
			_malfunctionChance = configFile.Bind<int>("4. Ghost Hand Malfunction", "2. Malfunction Chance", 86, "Defines the chance, if a malfunction is executed").Value;
		}

		public override void TouchInteract(PlayerControllerB playerControllerB)
		{
			//IL_0073: 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_00b3: Unknown result type (might be due to invalid IL or missing references)
			if (doorLock != null && Object.op_Implicit((Object)(object)doorLock) && !doorLock.isDoorOpened)
			{
				DoorLocker component = ((Component)doorLock).gameObject.GetComponent<DoorLocker>();
				if (component == null)
				{
					MalfunctioningDoors.Logger.LogFatal((object)"No DoorLocker found?!");
					return;
				}
				DoorBreach.DoorNetworkManager.SetDoorOpenServerRpc(NetworkObjectReference.op_Implicit(((NetworkBehaviour)doorLock).NetworkObject), (int)playerControllerB.playerClientId, true);
				PlayGhostHandSound();
				CreateGhostHand((Component)(object)playerControllerB);
				playerControllerB.DamagePlayer(10, true, true, (CauseOfDeath)1, 1, false, playerControllerB.velocityLastFrame);
				Landmine.SpawnExplosion(((Component)doorLock).transform.position, false, 0f, 0f, 50, 15f, (GameObject)null, false);
			}
		}

		private static void CreateGhostHand(Component playerControllerB)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: 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_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			Vector3 position = playerControllerB.transform.position;
			Vector3 val = default(Vector3);
			((Vector3)(ref val))..ctor(position.x, position.y + 1f, position.z);
			Object obj = Object.Instantiate(MalfunctioningDoors.ghostHandPrefab, val, new Quaternion(0f, 0f, 0f, 0f));
			GameObject val2 = (GameObject)(object)((obj is GameObject) ? obj : null);
			if (val2 == null)
			{
				MalfunctioningDoors.Logger.LogFatal((object)"Something went wrong while trying to instantiate the GhostHands!");
				return;
			}
			val2.transform.LookAt(playerControllerB.transform);
			Transform transform = val2.transform;
			transform.rotation *= Quaternion.Euler(0f, 90f, 0f);
			val2.transform.position = val;
			Transform transform2 = val2.transform;
			transform2.localScale *= 1.8f;
			GhostHandRotator ghostHandRotator = val2.AddComponent<GhostHandRotator>();
			ghostHandRotator.playerControllerTransform = playerControllerB.transform;
		}

		public override void UseInteract(PlayerControllerB playerControllerB)
		{
		}

		public override void UseKey()
		{
		}

		public override bool ShouldExecute()
		{
			return SyncedRandom.Next(0, 100) <= _malfunctionChance && !IsDestroyed();
		}

		private void PlayGhostHandSound()
		{
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Expected O, but got Unknown
			int num = SyncedRandom.Next(0, MalfunctioningDoors.GhostHandSfxList.Length);
			AudioClip val = MalfunctioningDoors.GhostHandSfxList[num];
			MalfunctioningDoors.Logger.LogDebug((object)$"Playing clip '{((Object)val).name}' ({num})");
			GameObject val2 = new GameObject("TemporaryGhostHandAudio");
			AudioSource val3 = val2.AddComponent<AudioSource>();
			val3.clip = val;
			val3.volume = 2f;
			val3.Play();
			Object.Destroy((Object)(object)val2, val.length);
		}
	}
	[Malfunction(80)]
	public class NoYouMalfunction : MalfunctionalDoor
	{
		[CompilerGenerated]
		private sealed class <StartRotation>d__8 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public PlayerControllerB playerControllerB;

			public float direction;

			private float <terminate>5__1;

			private Quaternion <startRotation>5__2;

			private float <targetRotationY>5__3;

			private float <currentAngle>5__4;

			private float <rotationSpeed>5__5;

			private float <>s__6;

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

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

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

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

			private bool MoveNext()
			{
				//IL_003a: 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_004b: 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_01ef: Unknown result type (might be due to invalid IL or missing references)
				//IL_01ff: Unknown result type (might be due to invalid IL or missing references)
				//IL_0177: Unknown result type (might be due to invalid IL or missing references)
				//IL_015a: Unknown result type (might be due to invalid IL or missing references)
				//IL_01a2: Unknown result type (might be due to invalid IL or missing references)
				//IL_01b8: Unknown result type (might be due to invalid IL or missing references)
				//IL_01bd: Unknown result type (might be due to invalid IL or missing references)
				//IL_01c0: Unknown result type (might be due to invalid IL or missing references)
				//IL_01d3: Unknown result type (might be due to invalid IL or missing references)
				//IL_01dd: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<terminate>5__1 = 1f;
					<startRotation>5__2 = ((Component)playerControllerB).transform.rotation;
					<targetRotationY>5__3 = ((Quaternion)(ref <startRotation>5__2)).eulerAngles.y + 90f * direction;
					<currentAngle>5__4 = ((Quaternion)(ref <startRotation>5__2)).eulerAngles.y;
					<rotationSpeed>5__5 = 0f;
					break;
				case 1:
					<>1__state = -1;
					break;
				}
				if (Quaternion.Angle(<startRotation>5__2, ((Component)playerControllerB).transform.rotation) < 90f)
				{
					<terminate>5__1 -= Time.deltaTime;
					if (<terminate>5__1 <= 0f)
					{
						return false;
					}
					float num = <rotationSpeed>5__5;
					<>s__6 = num;
					if (!(<>s__6 < 10f))
					{
						if (<>s__6 > 5f)
						{
							<rotationSpeed>5__5 -= Time.deltaTime * 5f;
						}
					}
					else
					{
						<rotationSpeed>5__5 += Time.deltaTime * 10f;
					}
					<currentAngle>5__4 += <rotationSpeed>5__5 * Time.deltaTime * 240f * direction;
					<currentAngle>5__4 = ((direction > 0f) ? Mathf.Clamp(<currentAngle>5__4, ((Quaternion)(ref <startRotation>5__2)).eulerAngles.y, <targetRotationY>5__3) : Mathf.Clamp(<currentAngle>5__4, <targetRotationY>5__3, ((Quaternion)(ref <startRotation>5__2)).eulerAngles.y));
					PlayerControllerB obj = playerControllerB;
					Vector3 position = ((Component)playerControllerB).transform.position;
					Quaternion val = Quaternion.Euler(0f, <currentAngle>5__4, 0f);
					obj.TeleportPlayer(position, true, ((Quaternion)(ref val)).eulerAngles.y, false, true);
					<>2__current = (object)new WaitForEndOfFrame();
					<>1__state = 1;
					return true;
				}
				return false;
			}

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

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

		private static int _malfunctionChance = 35;

		private static Random SyncedRandom => DoorLockPatch.SyncedRandom;

		private void Start()
		{
			doorLock = ((Component)this).GetComponent<DoorLock>();
		}

		public static int OverrideWeight(ConfigFile configFile)
		{
			return configFile.Bind<int>("6. No You", "1. Malfunction Weight", 80, "Defines the weight of a malfunction. The higher, the more likely it is to appear").Value;
		}

		public new static void InitializeConfig(ConfigFile configFile)
		{
			_malfunctionChance = configFile.Bind<int>("6. No You", "2. Malfunction Chance", 35, "Defines the chance, if a malfunction is executed").Value;
		}

		public override void TouchInteract(PlayerControllerB playerControllerB)
		{
		}

		public override void UseInteract(PlayerControllerB playerControllerB)
		{
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			if (doorLock != null && Object.op_Implicit((Object)(object)doorLock))
			{
				int num = 1;
				if (SyncedRandom.Next(0, 2) > 0)
				{
					num = -num;
				}
				((MonoBehaviour)this).StartCoroutine(StartRotation(playerControllerB, num));
				playerControllerB.JumpToFearLevel(1f, true);
				DoorLocker component = ((Component)doorLock).gameObject.GetComponent<DoorLocker>();
				if (component == null)
				{
					MalfunctioningDoors.Logger.LogFatal((object)"No DoorLocker found?!");
				}
				else
				{
					DoorBreach.DoorNetworkManager.SetDoorOpenServerRpc(NetworkObjectReference.op_Implicit(((NetworkBehaviour)doorLock).NetworkObject), (int)playerControllerB.playerClientId, !doorLock.isDoorOpened);
				}
			}
		}

		[IteratorStateMachine(typeof(<StartRotation>d__8))]
		private static IEnumerator StartRotation(PlayerControllerB playerControllerB, float direction)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <StartRotation>d__8(0)
			{
				playerControllerB = playerControllerB,
				direction = direction
			};
		}

		public override void UseKey()
		{
		}

		public override bool ShouldExecute()
		{
			return SyncedRandom.Next(0, 100) <= _malfunctionChance && !IsDestroyed();
		}
	}
	[Malfunction(150)]
	public class RandomOpenCloseMalfunction : MalfunctionalDoor
	{
		[CompilerGenerated]
		private sealed class <StartWaiting>d__12 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public RandomOpenCloseMalfunction <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				//IL_003b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0045: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>4__this._waiting = true;
					<>2__current = (object)new WaitForSeconds((float)SyncedRandom.Next(5, 30));
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<>4__this._waiting = false;
					return false;
				}
			}

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

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

		private static int _malfunctionChance = 40;

		private bool _waiting;

		private static Random SyncedRandom => DoorLockPatch.SyncedRandom;

		private void Start()
		{
			doorLock = ((Component)this).GetComponent<DoorLock>();
		}

		private void Update()
		{
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			if (_waiting)
			{
				return;
			}
			((MonoBehaviour)this).StartCoroutine(StartWaiting());
			if (doorLock == null || !Object.op_Implicit((Object)(object)doorLock))
			{
				return;
			}
			int num = SyncedRandom.Next(0, 100);
			if (num < _malfunctionChance)
			{
				DoorLocker component = ((Component)doorLock).gameObject.GetComponent<DoorLocker>();
				if (component == null)
				{
					MalfunctioningDoors.Logger.LogFatal((object)"No DoorLocker found?!");
					return;
				}
				bool flag = !doorLock.isDoorOpened;
				DoorBreach.DoorNetworkManager.SetDoorOpenServerRpc(NetworkObjectReference.op_Implicit(((NetworkBehaviour)doorLock).NetworkObject), ActionSource.ToInt((Source)(-665)), flag);
			}
		}

		public static int OverrideWeight(ConfigFile configFile)
		{
			return configFile.Bind<int>("5. Random Open Close Malfunction", "1. Malfunction Weight", 150, "Defines the weight of a malfunction. The higher, the more likely it is to appear").Value;
		}

		public new static void InitializeConfig(ConfigFile configFile)
		{
			_malfunctionChance = configFile.Bind<int>("5. Random Open Close Malfunction", "2. Malfunction Chance", 40, "Defines the chance, if a malfunction is executed").Value;
		}

		public override void TouchInteract(PlayerControllerB playerControllerB)
		{
		}

		public override void UseInteract(PlayerControllerB playerControllerB)
		{
		}

		public override void UseKey()
		{
		}

		public override bool ShouldExecute()
		{
			return false;
		}

		[IteratorStateMachine(typeof(<StartWaiting>d__12))]
		private IEnumerator StartWaiting()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <StartWaiting>d__12(0)
			{
				<>4__this = this
			};
		}
	}
}
namespace MalfunctioningDoors.Functional
{
	public class GhostHandRotator : MonoBehaviour
	{
		[CompilerGenerated]
		private sealed class <DestroyLater>d__3 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public float waitForSeconds;

			public GhostHandRotator <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0032: Unknown result type (might be due to invalid IL or missing references)
				//IL_003c: Expected O, but got Unknown
				//IL_004d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0057: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitForSeconds(waitForSeconds);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<>2__current = (object)new WaitForEndOfFrame();
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					Object.Destroy((Object)(object)((Component)<>4__this).gameObject);
					return false;
				}
			}

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

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

		internal Transform? playerControllerTransform;

		private void Start()
		{
			((MonoBehaviour)this).StartCoroutine(DestroyLater(3f));
		}

		private void Update()
		{
			//IL_002e: 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_0047: Unknown result type (might be due to invalid IL or missing references)
			if (Object.op_Implicit((Object)(object)playerControllerTransform))
			{
				((Component)this).transform.LookAt(playerControllerTransform);
				Transform transform = ((Component)this).transform;
				transform.rotation *= Quaternion.Euler(0f, 90f, 0f);
			}
		}

		[IteratorStateMachine(typeof(<DestroyLater>d__3))]
		private IEnumerator DestroyLater(float waitForSeconds)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <DestroyLater>d__3(0)
			{
				<>4__this = this,
				waitForSeconds = waitForSeconds
			};
		}
	}
}
namespace MalfunctioningDoors.Dependencies
{
	internal static class DependencyChecker
	{
		internal static bool IsLobbyCompatibilityInstalled()
		{
			return Chainloader.PluginInfos.Values.Any((PluginInfo metadata) => metadata.Metadata.GUID.Contains("LobbyCompatibility"));
		}
	}
	internal static class LobbyCompatibilitySupport
	{
		internal static void Initialize()
		{
			PluginHelper.RegisterPlugin("TestAccount666.MalfunctioningDoors", new Version("1.14.0"), (CompatibilityLevel)2, (VersionStrictness)2);
		}
	}
}
namespace __GEN
{
	internal class NetworkVariableSerializationHelper
	{
		[RuntimeInitializeOnLoadMethod]
		internal static void InitializeSerialization()
		{
		}
	}
}
namespace TestAccount666.MalfunctioningDoors.NetcodePatcher
{
	[AttributeUsage(AttributeTargets.Module)]
	internal class NetcodePatchedAssemblyAttribute : Attribute
	{
	}
}