using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using 48contingency.NetcodePatcher;
using BepInEx;
using BepInEx.Logging;
using Dawn;
using GameNetcodeStuff;
using HarmonyLib;
using JLL.Components;
using Microsoft.CodeAnalysis;
using Unity.Netcode;
using UnityEngine;
using UnityEngine.Events;

[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("48contingency")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+d44cc4d98c55e08eb1f2ac40ff65493bbc4acd02")]
[assembly: AssemblyProduct("48contingency")]
[assembly: AssemblyTitle("48contingency")]
[assembly: AssemblyVersion("1.0.0.0")]
[module: RefSafetyRules(11)]
[module: NetcodePatchedAssembly]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[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]
	[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]
	[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 OpaliteMoonMod
{
	public class ApparatusDockHandler : NetworkBehaviour
	{
		public bool isPowered;

		public RoundManager roundManager;

		public Animator thisDockAnimator;

		public AudioSource dockingPointAudio;

		private Coroutine connectAnimation;

		private Coroutine roomPowerAnimation;

		private Coroutine roomFlickerAnimation;

		public AudioClip[] dockingAudios;

		public Transform apparatusPoint;

		private LungProp dockedApparatus;

		public Animator DockLightAnimator;

		public float timeAtLastUse;

		public GameObject[] poweredRoomObjects;

		public List<Animator> poweredRoomLightAnimators = new List<Animator>();

		private InteractTrigger triggerScript;

		private float playbackTime;

		private void Awake()
		{
			isPowered = false;
			triggerScript = ((Component)this).gameObject.GetComponent<InteractTrigger>();
			GameObject[] array = poweredRoomObjects;
			foreach (GameObject val in array)
			{
				Animator component = val.GetComponent<Animator>();
				if ((Object)(object)component != (Object)null)
				{
					poweredRoomLightAnimators.Add(component);
					component.SetBool("On", false);
				}
			}
		}

		private void Start()
		{
			roundManager = Object.FindObjectOfType<RoundManager>();
		}

		public void FinishOpening()
		{
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			if (!GetDockAnimators())
			{
				return;
			}
			thisDockAnimator.SetBool("Open", false);
			NetworkObject apparatusFromInteractingPlayer = GetApparatusFromInteractingPlayer();
			if ((Object)(object)apparatusFromInteractingPlayer == (Object)null)
			{
				CancelOpening();
				return;
			}
			PlayerControllerB localPlayerController = GameNetworkManager.Instance.localPlayerController;
			if ((Object)(object)localPlayerController != (Object)null && (Object)(object)localPlayerController.currentlyHeldObjectServer != (Object)null)
			{
				NetworkObject val = GetApparatusParentNetworkObject();
				if ((Object)(object)val == (Object)null)
				{
					val = ((NetworkBehaviour)this).NetworkObject;
				}
				if ((Object)(object)val != (Object)null)
				{
					localPlayerController.DiscardHeldObject(true, val, Vector3.zero, true);
				}
				else
				{
					localPlayerController.DiscardHeldObject(false, (NetworkObject)null, default(Vector3), true);
				}
			}
			PlaceApparatusServerRpc(new NetworkObjectReference(apparatusFromInteractingPlayer));
		}

		public void CancelOpening()
		{
			if (GetDockAnimators())
			{
				thisDockAnimator.SetBool("Open", false);
				SyncCancelOpeningRpc();
			}
		}

		[Rpc(/*Could not decode attribute arguments.*/)]
		public void SyncCancelOpeningRpc()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Invalid comparison between Unknown and I4
			//IL_0043: 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_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1)
			{
				RpcAttributeParams val = new RpcAttributeParams
				{
					RequireOwnership = false
				};
				RpcParams val3 = default(RpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendRpc(2969337566u, val3, val, (SendTo)5, (RpcDelivery)0);
				((NetworkBehaviour)this).__endSendRpc(ref val2, 2969337566u, val3, val, (SendTo)5, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1)
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				if (GetDockAnimators())
				{
					thisDockAnimator.SetBool("Open", false);
				}
			}
		}

		private NetworkObject? GetApparatusFromInteractingPlayer()
		{
			PlayerControllerB localPlayerController = GameNetworkManager.Instance.localPlayerController;
			if ((Object)(object)localPlayerController == (Object)null || !localPlayerController.isHoldingObject || (Object)(object)localPlayerController.currentlyHeldObjectServer == (Object)null)
			{
				return null;
			}
			GrabbableObject currentlyHeldObjectServer = localPlayerController.currentlyHeldObjectServer;
			if (!(currentlyHeldObjectServer is LungProp))
			{
				return null;
			}
			return ((NetworkBehaviour)currentlyHeldObjectServer).NetworkObject;
		}

		private bool LocalPlayerHoldingApparatus()
		{
			PlayerControllerB localPlayerController = GameNetworkManager.Instance.localPlayerController;
			if ((Object)(object)localPlayerController == (Object)null || !localPlayerController.isHoldingObject)
			{
				return false;
			}
			return localPlayerController.currentlyHeldObjectServer is LungProp;
		}

		[Rpc(/*Could not decode attribute arguments.*/)]
		private void PlaceApparatusServerRpc(NetworkObjectReference apparatusRef)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Invalid comparison between Unknown and I4
			//IL_0043: 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_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_016b: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1)
			{
				RpcAttributeParams val = new RpcAttributeParams
				{
					RequireOwnership = false
				};
				RpcParams val3 = default(RpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendRpc(2430895006u, val3, val, (SendTo)2, (RpcDelivery)0);
				((FastBufferWriter)(ref val2)).WriteValueSafe<NetworkObjectReference>(ref apparatusRef, default(ForNetworkSerializable));
				((NetworkBehaviour)this).__endSendRpc(ref val2, 2430895006u, val3, val, (SendTo)2, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage != 1)
			{
				return;
			}
			base.__rpc_exec_stage = (__RpcExecStage)0;
			NetworkObject val4 = default(NetworkObject);
			if (isPowered || !((NetworkObjectReference)(ref apparatusRef)).TryGet(ref val4, (NetworkManager)null))
			{
				return;
			}
			LungProp component = ((Component)val4).GetComponent<LungProp>();
			if ((Object)(object)component == (Object)null)
			{
				return;
			}
			NetworkObject apparatusParentNetworkObject = GetApparatusParentNetworkObject();
			if ((Object)(object)apparatusParentNetworkObject == (Object)null)
			{
				OpaliteMoonPlugin.Log.LogDebug((object)"[ApparatusDock] apparatusPoint has no NetworkObject");
				return;
			}
			isPowered = true;
			if (val4.IsSpawned && val4.OwnerClientId != 0)
			{
				val4.ChangeOwnership(0uL);
			}
			DockApparatusLocal(component, val4, stripHolder: true);
			PlaceApparatusClientRpc(apparatusRef);
		}

		[Rpc(/*Could not decode attribute arguments.*/)]
		private void PlaceApparatusClientRpc(NetworkObjectReference apparatusRef)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Invalid comparison between Unknown and I4
			//IL_0043: 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_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1)
			{
				RpcAttributeParams val = default(RpcAttributeParams);
				RpcParams val3 = default(RpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendRpc(2400349129u, val3, val, (SendTo)7, (RpcDelivery)0);
				((FastBufferWriter)(ref val2)).WriteValueSafe<NetworkObjectReference>(ref apparatusRef, default(ForNetworkSerializable));
				((NetworkBehaviour)this).__endSendRpc(ref val2, 2400349129u, val3, val, (SendTo)7, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage != 1)
			{
				return;
			}
			base.__rpc_exec_stage = (__RpcExecStage)0;
			NetworkObject val4 = default(NetworkObject);
			if (!((NetworkObjectReference)(ref apparatusRef)).TryGet(ref val4, (NetworkManager)null))
			{
				return;
			}
			LungProp component = ((Component)val4).GetComponent<LungProp>();
			if (!((Object)(object)component == (Object)null))
			{
				isPowered = true;
				dockedApparatus = component;
				DockApparatusLocal(component, val4, stripHolder: true);
				if (GetDockAnimators())
				{
					thisDockAnimator.SetBool("Open", false);
					thisDockAnimator.SetBool("Powered", true);
				}
				if ((Object)(object)triggerScript != (Object)null)
				{
					triggerScript.interactable = false;
					triggerScript.hoverTip = "[Locked]";
					triggerScript.disabledHoverTip = "[Locked]";
				}
				if (connectAnimation == null)
				{
					connectAnimation = ((MonoBehaviour)this).StartCoroutine(ConnectToMachinery());
				}
				TurnOnRoomLights();
			}
		}

		private void DockApparatusLocal(LungProp prop, NetworkObject apparatus, bool stripHolder)
		{
			//IL_0163: Unknown result type (might be due to invalid IL or missing references)
			//IL_0183: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ea: 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_020e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0213: Unknown result type (might be due to invalid IL or missing references)
			//IL_0218: Unknown result type (might be due to invalid IL or missing references)
			//IL_0227: Unknown result type (might be due to invalid IL or missing references)
			//IL_0238: Unknown result type (might be due to invalid IL or missing references)
			//IL_0249: Unknown result type (might be due to invalid IL or missing references)
			//IL_0258: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)prop == (Object)null || (Object)(object)apparatus == (Object)null)
			{
				return;
			}
			NetworkObject apparatusParentNetworkObject = GetApparatusParentNetworkObject();
			Transform val = (Transform)(((Object)(object)apparatusPoint != (Object)null) ? ((object)apparatusPoint) : ((object)(((Object)(object)apparatusParentNetworkObject != (Object)null) ? ((Component)apparatusParentNetworkObject).transform : null)));
			if (stripHolder)
			{
				PlayerControllerB val2 = ((GrabbableObject)prop).playerHeldBy;
				PlayerControllerB val3 = (((Object)(object)GameNetworkManager.Instance != (Object)null) ? GameNetworkManager.Instance.localPlayerController : null);
				if ((Object)(object)val2 == (Object)null && (Object)(object)val3 != (Object)null && (Object)(object)val3.currentlyHeldObjectServer == (Object)(object)prop)
				{
					val2 = val3;
				}
				if ((Object)(object)val2 != (Object)null && (Object)(object)val2 == (Object)(object)val3)
				{
					NetworkObject apparatusParentNetworkObject2 = GetApparatusParentNetworkObject();
					val2.DiscardHeldObject(true, apparatusParentNetworkObject2, Vector3.zero, true);
				}
				if ((Object)(object)val2 != (Object)null)
				{
					val2.currentlyHeldObjectServer = null;
					val2.isHoldingObject = false;
					val2.twoHanded = false;
				}
			}
			if ((Object)(object)apparatusParentNetworkObject != (Object)null)
			{
				if ((Object)(object)((Component)apparatus).transform.parent != (Object)(object)((Component)apparatusParentNetworkObject).transform)
				{
					apparatus.TrySetParent(apparatusParentNetworkObject, false);
				}
			}
			else if ((Object)(object)val != (Object)null)
			{
				((Component)apparatus).transform.SetParent(val, false);
			}
			((Component)apparatus).transform.localPosition = Vector3.zero;
			((Component)apparatus).transform.localEulerAngles = new Vector3(0f, 180f, 0f);
			BoxCollider component = ((Component)prop).GetComponent<BoxCollider>();
			if ((Object)(object)component != (Object)null && (Object)(object)triggerScript != (Object)null)
			{
				((Collider)component).enabled = false;
				BoxCollider val4 = ((Component)triggerScript).gameObject.AddComponent<BoxCollider>();
				val4.center = ((Component)triggerScript).transform.InverseTransformPoint(((Component)component).transform.TransformPoint(component.center));
				val4.size = ((Component)triggerScript).transform.InverseTransformVector(((Component)component).transform.TransformVector(component.size));
				val4.size = new Vector3(Mathf.Abs(val4.size.x), Mathf.Abs(val4.size.y), Mathf.Abs(val4.size.z));
				((Collider)val4).isTrigger = false;
			}
			if ((Object)(object)val != (Object)null)
			{
				((GrabbableObject)prop).parentObject = val;
			}
			else if ((Object)(object)apparatusParentNetworkObject != (Object)null)
			{
				((GrabbableObject)prop).parentObject = ((Component)apparatusParentNetworkObject).transform;
			}
			((GrabbableObject)prop).isHeld = false;
			((GrabbableObject)prop).playerHeldBy = null;
			((GrabbableObject)prop).hasHitGround = true;
			((GrabbableObject)prop).grabbable = false;
			((GrabbableObject)prop).grabbableToEnemies = false;
			((GrabbableObject)prop).fallTime = 1f;
		}

		private NetworkObject GetApparatusParentNetworkObject()
		{
			if ((Object)(object)apparatusPoint != (Object)null)
			{
				NetworkObject component = ((Component)apparatusPoint).GetComponent<NetworkObject>();
				if ((Object)(object)component != (Object)null)
				{
					return component;
				}
				component = ((Component)apparatusPoint).GetComponentInParent<NetworkObject>();
				if ((Object)(object)component != (Object)null)
				{
					return component;
				}
			}
			return ((NetworkBehaviour)this).NetworkObject;
		}

		public void FlickerRoomLights()
		{
			if (roomFlickerAnimation == null)
			{
				roomFlickerAnimation = ((MonoBehaviour)this).StartCoroutine(FlickerPoweredLightsControlRoom());
			}
		}

		public void TurnOnRoomLights()
		{
			if (roomPowerAnimation == null)
			{
				roomPowerAnimation = ((MonoBehaviour)this).StartCoroutine(RoomPowerAnimation());
			}
		}

		private IEnumerator RoomPowerAnimation()
		{
			_ = new float[poweredRoomObjects.Length];
			float propogationSpeed = 7f;
			List<GameObject> sortedObjects = poweredRoomObjects.OrderBy((GameObject val) => Vector3.Distance(val.transform.position, apparatusPoint.position)).ToList();
			float timeSpent = 0f;
			foreach (GameObject obj in sortedObjects)
			{
				float delay = Vector3.Distance(obj.transform.position, apparatusPoint.position) / propogationSpeed;
				float wait = delay - timeSpent;
				if (wait > 0f)
				{
					yield return (object)new WaitForSeconds(wait);
					timeSpent = delay;
				}
				obj.SetActive(true);
				Animator animator = obj.GetComponent<Animator>();
				if ((Object)(object)animator != (Object)null)
				{
					animator.SetBool("on", true);
				}
			}
			yield return (object)new WaitForSeconds(0.2f);
			FlickerRoomLights();
			yield return null;
		}

		private IEnumerator FlickerPoweredLightsControlRoom(bool flickerFlashlights = false, bool disableFlashlights = false)
		{
			OpaliteMoonPlugin.Log.LogDebug((object)"Flickering Control Room lights");
			if (poweredRoomLightAnimators.Count <= 0 || !((Object)(object)poweredRoomLightAnimators[0] != (Object)null))
			{
				yield break;
			}
			int loopCount = 0;
			int b = 4;
			while (b > 0 && b != 0)
			{
				for (int j = loopCount; j < poweredRoomLightAnimators.Count / b; j++)
				{
					loopCount++;
					poweredRoomLightAnimators[j].SetTrigger("Flicker");
				}
				yield return (object)new WaitForSeconds(0.05f);
				b--;
			}
		}

		private IEnumerator ConnectToMachinery()
		{
			GameObject newSparkParticle = null;
			if ((Object)(object)dockedApparatus != (Object)null && (Object)(object)dockedApparatus.sparkParticle != (Object)null)
			{
				newSparkParticle = Object.Instantiate<GameObject>(dockedApparatus.sparkParticle, ((Component)dockedApparatus).transform.position, Quaternion.identity, ((Component)dockedApparatus).transform);
			}
			dockingPointAudio.PlayOneShot(dockingAudios[0], 0.7f);
			yield return (object)new WaitForSeconds(0.1f);
			if ((Object)(object)newSparkParticle != (Object)null)
			{
				newSparkParticle.SetActive(true);
			}
			yield return (object)new WaitForSeconds(0.3f);
			if ((Object)(object)roundManager != (Object)null)
			{
				roundManager.FlickerLights(false, false);
			}
			yield return (object)new WaitForSeconds(1f);
			if ((Object)(object)newSparkParticle != (Object)null)
			{
				Object.Destroy((Object)(object)newSparkParticle, 2f);
			}
			connectAnimation = null;
			yield return null;
		}

		public void StartOpening()
		{
			if (!isPowered && LocalPlayerHoldingApparatus() && GetDockAnimators() && !(Time.realtimeSinceStartup - timeAtLastUse < 0.5f))
			{
				timeAtLastUse = Time.realtimeSinceStartup;
				thisDockAnimator.SetBool("Open", true);
				SyncStartOpeningRpc();
			}
		}

		[Rpc(/*Could not decode attribute arguments.*/)]
		public void SyncStartOpeningRpc()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Invalid comparison between Unknown and I4
			//IL_0043: 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_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1)
			{
				RpcAttributeParams val = new RpcAttributeParams
				{
					RequireOwnership = false
				};
				RpcParams val3 = default(RpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendRpc(1126231677u, val3, val, (SendTo)5, (RpcDelivery)0);
				((NetworkBehaviour)this).__endSendRpc(ref val2, 1126231677u, val3, val, (SendTo)5, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1)
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				if (GetDockAnimators())
				{
					thisDockAnimator.SetBool("Open", true);
				}
			}
		}

		private bool GetDockAnimators()
		{
			return (Object)(object)thisDockAnimator != (Object)null;
		}

		private void LateUpdate()
		{
			if (!((Object)(object)triggerScript == (Object)null))
			{
				if (!isPowered)
				{
					thisDockAnimator.SetBool("Powered", false);
				}
				bool flag = LocalPlayerHoldingApparatus() && !isPowered;
				triggerScript.interactable = flag;
				triggerScript.hoverTip = (flag ? "Insert Apparatus : [LMB]" : "");
				triggerScript.disabledHoverTip = (isPowered ? "[Locked]" : "[Requires Apparatus]");
			}
		}

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

		protected override void __initializeRpcs()
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Expected O, but got Unknown
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Expected O, but got Unknown
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Expected O, but got Unknown
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Expected O, but got Unknown
			((NetworkBehaviour)this).__registerRpc(2969337566u, new RpcReceiveHandler(__rpc_handler_2969337566), "SyncCancelOpeningRpc");
			((NetworkBehaviour)this).__registerRpc(2430895006u, new RpcReceiveHandler(__rpc_handler_2430895006), "PlaceApparatusServerRpc");
			((NetworkBehaviour)this).__registerRpc(2400349129u, new RpcReceiveHandler(__rpc_handler_2400349129), "PlaceApparatusClientRpc");
			((NetworkBehaviour)this).__registerRpc(1126231677u, new RpcReceiveHandler(__rpc_handler_1126231677), "SyncStartOpeningRpc");
			((NetworkBehaviour)this).__initializeRpcs();
		}

		private static void __rpc_handler_2969337566(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((ApparatusDockHandler)(object)target).SyncCancelOpeningRpc();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2430895006(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				NetworkObjectReference apparatusRef = default(NetworkObjectReference);
				((FastBufferReader)(ref reader)).ReadValueSafe<NetworkObjectReference>(ref apparatusRef, default(ForNetworkSerializable));
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((ApparatusDockHandler)(object)target).PlaceApparatusServerRpc(apparatusRef);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2400349129(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				NetworkObjectReference apparatusRef = default(NetworkObjectReference);
				((FastBufferReader)(ref reader)).ReadValueSafe<NetworkObjectReference>(ref apparatusRef, default(ForNetworkSerializable));
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((ApparatusDockHandler)(object)target).PlaceApparatusClientRpc(apparatusRef);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1126231677(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((ApparatusDockHandler)(object)target).SyncStartOpeningRpc();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		protected internal override string __getTypeName()
		{
			return "ApparatusDockHandler";
		}
	}
	public enum DockingInteractions
	{
		Early,
		Late,
		Cancel
	}
	public class ContingencyWaterTrigger : MonoBehaviour
	{
		public bool isWater;

		public bool isInsideWater;

		public int audioClipIndex;

		[Space(5f)]
		public bool sinkingLocalPlayer;

		public float movementHinderance = 1.6f;

		public float sinkingSpeedMultiplier = 0.15f;

		private void OnTriggerStay(Collider other)
		{
			//IL_0192: Unknown result type (might be due to invalid IL or missing references)
			if (isWater)
			{
				if (!((Component)other).gameObject.CompareTag("Player"))
				{
					return;
				}
				PlayerControllerB component = ((Component)other).gameObject.GetComponent<PlayerControllerB>();
				if ((Object)(object)component != (Object)(object)GameNetworkManager.Instance.localPlayerController && (Object)(object)component != (Object)null && (Object)(object)component.underwaterCollider != (Object)(object)this)
				{
					component.underwaterCollider = ((Component)this).gameObject.GetComponent<Collider>();
					return;
				}
			}
			if (!isWater && !((Component)other).gameObject.CompareTag("Player"))
			{
				return;
			}
			PlayerControllerB component2 = ((Component)other).gameObject.GetComponent<PlayerControllerB>();
			if ((Object)(object)component2 != (Object)(object)GameNetworkManager.Instance.localPlayerController)
			{
				return;
			}
			if ((isWater && component2.isInsideFactory != isInsideWater) || component2.isInElevator)
			{
				if (sinkingLocalPlayer)
				{
					StopSinkingLocalPlayer(component2);
				}
				return;
			}
			if (isWater && !component2.isUnderwater)
			{
				component2.underwaterCollider = ((Component)this).gameObject.GetComponent<Collider>();
				component2.isUnderwater = true;
				if (!isInsideWater && (Object)(object)GameNetworkManager.Instance.localPlayerController == (Object)(object)component2 && (component2.isFallingFromJump || component2.isFallingNoJump) && component2.fallValue < -4f)
				{
					TimeOfDay.Instance.WaterSplashEffect(((Component)component2).transform.position, component2.fallValue > -17f, true);
				}
			}
			component2.statusEffectAudioIndex = audioClipIndex;
			if (component2.isSinking)
			{
				return;
			}
			if (sinkingLocalPlayer)
			{
				if (!component2.CheckConditionsForSinkingInQuicksand())
				{
					StopSinkingLocalPlayer(component2);
				}
			}
			else if (component2.CheckConditionsForSinkingInQuicksand())
			{
				sinkingLocalPlayer = true;
				component2.sourcesCausingSinking++;
				component2.isMovementHindered++;
				component2.hinderedMultiplier *= movementHinderance;
				if (isWater)
				{
					component2.sinkingSpeedMultiplier = 0f;
				}
				else
				{
					component2.sinkingSpeedMultiplier = sinkingSpeedMultiplier;
				}
			}
		}

		private void OnTriggerExit(Collider other)
		{
			OnExit(other);
		}

		public void OnExit(Collider other)
		{
			PlayerControllerB val = null;
			if (!sinkingLocalPlayer)
			{
				if (isWater && ((Component)other).CompareTag("Player"))
				{
					val = ((Component)other).gameObject.GetComponent<PlayerControllerB>();
					if (!((Object)(object)val != (Object)null) || !((Object)(object)val == (Object)(object)GameNetworkManager.Instance.localPlayerController))
					{
						val.isUnderwater = false;
					}
				}
			}
			else if (((Component)other).CompareTag("Player"))
			{
				if ((Object)(object)val == (Object)null)
				{
					val = ((Component)other).gameObject.GetComponent<PlayerControllerB>();
				}
				if (!((Object)(object)val != (Object)(object)GameNetworkManager.Instance.localPlayerController))
				{
					StopSinkingLocalPlayer(val);
				}
			}
		}

		public void StopSinkingLocalPlayer(PlayerControllerB playerScript)
		{
			if (sinkingLocalPlayer)
			{
				sinkingLocalPlayer = false;
				playerScript.sourcesCausingSinking = Mathf.Clamp(playerScript.sourcesCausingSinking - 1, 0, 100);
				playerScript.isMovementHindered = Mathf.Clamp(playerScript.isMovementHindered - 1, 0, 100);
				playerScript.hinderedMultiplier = Mathf.Clamp(playerScript.hinderedMultiplier / movementHinderance, 1f, 100f);
				if (playerScript.isMovementHindered == 0 && isWater)
				{
					playerScript.isUnderwater = false;
				}
			}
		}
	}
	public class ControlRoomManager : NetworkBehaviour
	{
		public static ControlRoomManager Instance;

		public ApparatusDockHandler dockHandler;

		public bool isRainingInside;

		public Random LockersRandom;

		public Random BasinRandom;

		public Random KyvidRandom;

		public AudioSource[] MiscAudios;

		public AudioClip[] miscClips;

		public GameObject[] controlRoomLights;

		public GameObject[] controlRoomLights2;

		public AudioSource MonitorAudio;

		public AudioClip monitorAlarmBeep;

		public AudioSource DoorAudio;

		public AudioClip doorOpeningSfx;

		public NetworkObject[] lockers;

		public List<PlayerControllerB> playersInsideControlRoom = new List<PlayerControllerB>();

		public ControlRoomTeleport controlRoomTeleport;

		public ControlRoomTeleport outdoorControlRoomTeleport;

		public EntranceTeleport controlRoomFireTeleport;

		public EntranceTeleport indoorFireTeleport;

		public Animator garageDoorAnimator;

		public bool hasBeenPowered;

		private bool isPoweredOld;

		private InteractTrigger controlRoomDoorTrigger;

		private InteractTrigger indoorDoorTrigger;

		private InteractTrigger controlRoomFireTrigger;

		private InteractTrigger indoorFireTrigger;

		private Renderer[] roomRenderers;

		public AudioSource AmbienceAudio;

		public AudioClip ambienceClip;

		public AudioSource DelugePumpAudio;

		public AudioClip delugePumpWhir;

		public AudioClip delugeFlow;

		public Animator reservoirWaterAnimator;

		public bool isDraining;

		private float drainTimer;

		private List<ItemSpawner> basinSpawners;

		private List<Renderer> renderers;

		private List<ItemSpawner> basinScrapSpawners = new List<ItemSpawner>();

		public Animator kyividAnimator;

		public int kyividState = 1;

		public ControlRoomSteamValve valve;

		public Animator PCAnimator;

		public WeightedItemRefrence[] customBasinScrapList;

		public void Awake()
		{
			renderers = GetActiveRenderers();
			if ((Object)(object)Instance == (Object)null)
			{
				Instance = this;
			}
			if ((Object)(object)dockHandler == (Object)null)
			{
				dockHandler = Object.FindObjectOfType<ApparatusDockHandler>();
			}
			SetExitReferences();
			AmbienceAudio.clip = ambienceClip;
			AmbienceAudio.Play();
			AmbienceAudio.loop = true;
			AmbienceAudio.volume = 0f;
		}

		public void StartUpPC()
		{
			PCAnimator.SetBool("On", true);
			if (MiscAudios.Length != 0 && (Object)(object)MiscAudios[0] != (Object)null)
			{
				MiscAudios[0].volume = 0.8f;
				MiscAudios[0].pitch = 0.5f;
				((MonoBehaviour)this).StartCoroutine(StopAudioAfterFade(MiscAudios[0], 0.5f));
			}
			((MonoBehaviour)this).StartCoroutine(PCAudiosCoroutine());
		}

		public IEnumerator PCAudiosCoroutine()
		{
			MonitorAudio.volume = 1f;
			if ((Object)(object)miscClips[1] != (Object)null)
			{
				MonitorAudio.PlayOneShot(miscClips[1]);
			}
			yield return (object)new WaitForSeconds(1f);
			yield return null;
		}

		public IEnumerator StopAudioAfterFade(AudioSource audioSource, float fadeSeconds)
		{
			float startingVolume = audioSource.volume;
			float currentTime = 0f;
			while (currentTime < fadeSeconds)
			{
				currentTime += Time.deltaTime;
				audioSource.volume = Mathf.Lerp(startingVolume, 0f, currentTime / fadeSeconds);
				yield return null;
			}
			audioSource.volume = 0f;
			audioSource.Stop();
			audioSource.volume = startingVolume;
		}

		public IEnumerator StartAudioWithFade(AudioSource audioSource, float fadeSeconds)
		{
			float targetVolume = audioSource.volume;
			float currentTime = 0f;
			audioSource.volume = 0f;
			audioSource.Play();
			while (currentTime < fadeSeconds)
			{
				currentTime += Time.deltaTime;
				audioSource.volume = Mathf.Lerp(0f, targetVolume, currentTime / fadeSeconds);
				yield return null;
			}
			audioSource.volume = targetVolume;
		}

		[Rpc(/*Could not decode attribute arguments.*/)]
		public void StartDelugeServerRpc()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Invalid comparison between Unknown and I4
			//IL_0043: 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_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1)
				{
					RpcAttributeParams val = new RpcAttributeParams
					{
						RequireOwnership = false
					};
					RpcParams val3 = default(RpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendRpc(1399946006u, val3, val, (SendTo)2, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendRpc(ref val2, 1399946006u, val3, val, (SendTo)2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1)
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					OpaliteMoonPlugin.Log.LogDebug((object)"Starting Deluge On Server");
					StartDelugeClientRpc();
				}
			}
		}

		[Rpc(/*Could not decode attribute arguments.*/)]
		public void StartDelugeClientRpc()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_0043: 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_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1)
				{
					RpcAttributeParams val = default(RpcAttributeParams);
					RpcParams val3 = default(RpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendRpc(545389115u, val3, val, (SendTo)7, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendRpc(ref val2, 545389115u, val3, val, (SendTo)7, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1)
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					OpaliteMoonPlugin.Log.LogDebug((object)"Starting Deluge On Client");
					((MonoBehaviour)this).StartCoroutine(DelugeFloodEvent());
					isDraining = true;
				}
			}
		}

		[Rpc(/*Could not decode attribute arguments.*/)]
		public void OnBeginPowerServerRpc()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Invalid comparison between Unknown and I4
			//IL_0043: 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_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1)
				{
					RpcAttributeParams val = new RpcAttributeParams
					{
						RequireOwnership = false
					};
					RpcParams val3 = default(RpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendRpc(2799117281u, val3, val, (SendTo)2, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendRpc(ref val2, 2799117281u, val3, val, (SendTo)2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1)
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					OnBeginPowerClientRpc();
				}
			}
		}

		[Rpc(/*Could not decode attribute arguments.*/)]
		public void OnBeginPowerClientRpc()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_0043: 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_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1)
				{
					RpcAttributeParams val = default(RpcAttributeParams);
					RpcParams val3 = default(RpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendRpc(565277397u, val3, val, (SendTo)7, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendRpc(ref val2, 565277397u, val3, val, (SendTo)7, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1)
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					AmbienceAudio.Stop();
					((MonoBehaviour)this).StartCoroutine(BigDoorOpen());
				}
			}
		}

		[Rpc(/*Could not decode attribute arguments.*/)]
		public void OnEndPowerClientRpc()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_0043: 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_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1)
				{
					RpcAttributeParams val = default(RpcAttributeParams);
					RpcParams val3 = default(RpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendRpc(1133039509u, val3, val, (SendTo)7, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendRpc(ref val2, 1133039509u, val3, val, (SendTo)7, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1)
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					((MonoBehaviour)this).StartCoroutine(BigDoorClose());
				}
			}
		}

		private void SetExitReferences()
		{
			InitExitListeners();
		}

		public void BeforeLoadNewLevel(int currentSeed)
		{
			if (!RoundManager.Instance.hasInitializedLevelRandomSeed)
			{
				OpaliteMoonPlugin.Log.LogDebug((object)"[ControlRoomManager.BeforeLoadNewLevel] wtf.");
			}
			OpaliteMoonPlugin.Log.LogDebug((object)$"[ControlRoomManager.BeforeLoadNewLevel] setting up lockers with seed {currentSeed}.");
			KyvidRandom = new Random(StartOfRound.Instance.randomMapSeed + 2352);
			kyividAnimator.SetInteger("state", kyividState);
			SetupLockersServerRpc();
			SetupBasinScrap();
		}

		private void SetupBasinScrap()
		{
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0109: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Expected O, but got Unknown
			//IL_012d: Unknown result type (might be due to invalid IL or missing references)
			//IL_013f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0144: Unknown result type (might be due to invalid IL or missing references)
			//IL_0156: Unknown result type (might be due to invalid IL or missing references)
			//IL_015b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0167: Unknown result type (might be due to invalid IL or missing references)
			//IL_016e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0173: Unknown result type (might be due to invalid IL or missing references)
			//IL_0185: Unknown result type (might be due to invalid IL or missing references)
			//IL_018a: Unknown result type (might be due to invalid IL or missing references)
			//IL_018f: Unknown result type (might be due to invalid IL or missing references)
			//IL_020c: Unknown result type (might be due to invalid IL or missing references)
			//IL_021d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0245: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01de: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ea: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = GameObject.Find("BasinScrapSpawns");
			if ((Object)(object)val == (Object)null)
			{
				Debug.LogError((object)"[ControlRoomManager] Could not find BasinScrapSpawns parent");
				return;
			}
			GameObject[] array = (from t in val.GetComponentsInChildren<Transform>(true)
				where ((Object)t).name.StartsWith("ScrapNode")
				select ((Component)t).gameObject).ToArray();
			int seed = StartOfRound.Instance.randomMapSeed + 393;
			BasinRandom = new Random(seed);
			int num = 6 + BasinRandom.Next(2);
			Debug.Log((object)$"[ControlRoomManager] setting up {num} basins scrap item spawners");
			Item item = ((Registry<DawnItemInfo>)(object)LethalContent.Items)[NamespacedKey<DawnItemInfo>.From("opalite_moon", "sopping_zed_dog")].Item;
			WeightedItemRefrence[] customList = (WeightedItemRefrence[])(object)new WeightedItemRefrence[1]
			{
				new WeightedItemRefrence
				{
					Weight = 100,
					Item = item,
					ItemName = "",
					FindRegisteredItem = false
				}
			};
			RaycastHit val3 = default(RaycastHit);
			for (int num2 = 0; num2 < num; num2++)
			{
				int num3 = BasinRandom.Next(0, array.Length);
				ItemSpawner val2 = new GameObject().AddComponent<ItemSpawner>();
				Vector2 randomPointInCircleForBasin = GetRandomPointInCircleForBasin(5f);
				((Component)val2).transform.position = array[num3].transform.position + new Vector3(randomPointInCircleForBasin.x, 5f, randomPointInCircleForBasin.y);
				while (!Physics.Raycast(((Component)val2).transform.position, -Vector3.up, ref val3, 80f, 268437761, (QueryTriggerInteraction)1))
				{
					randomPointInCircleForBasin = GetRandomPointInCircleForBasin(5f);
					((Component)val2).transform.position = array[num3].transform.position + new Vector3(randomPointInCircleForBasin.x, 5f, randomPointInCircleForBasin.y);
				}
				((Behaviour)val2).enabled = false;
				val2.spawnOnEnabled = true;
				val2.SourcePool = (SpawnPoolSource)0;
				val2.CustomList = customList;
				val2.spawnRotation = (RotationType)1;
				((Component)val2).transform.localEulerAngles = new Vector3(0f, (float)BasinRandom.Next(0, 360), 0f);
				basinScrapSpawners.Add(val2);
				((Component)val2).gameObject.SetActive(false);
			}
			Debug.Log((object)$"[ControlRoomManager] added {basinScrapSpawners.Count} item spawners to list");
		}

		public Vector2 GetRandomPointInCircleForBasin(float radius)
		{
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: 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)
			float num = (float)(BasinRandom.NextDouble() * 2.0 * 3.1415927410125732);
			float num2 = (float)Math.Sqrt(BasinRandom.NextDouble()) * radius;
			float num3 = num2 * Mathf.Cos(num);
			float num4 = num2 * Mathf.Sin(num);
			return new Vector2(num3, num4);
		}

		[Rpc(/*Could not decode attribute arguments.*/)]
		private void SetupLockersServerRpc()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Invalid comparison between Unknown and I4
			//IL_0043: 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_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1)
			{
				RpcAttributeParams val = new RpcAttributeParams
				{
					RequireOwnership = false
				};
				RpcParams val3 = default(RpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendRpc(228644649u, val3, val, (SendTo)2, (RpcDelivery)0);
				((NetworkBehaviour)this).__endSendRpc(ref val2, 228644649u, val3, val, (SendTo)2, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage != 1)
			{
				return;
			}
			base.__rpc_exec_stage = (__RpcExecStage)0;
			LockersRandom = new Random(StartOfRound.Instance.randomMapSeed + 214);
			bool[] array = new bool[lockers.Length];
			for (int i = 0; i < lockers.Length; i++)
			{
				if (LockersRandom.Next() % 4 != 0)
				{
					array[i] = true;
				}
			}
			SetupLockersClientRpc(array);
		}

		[Rpc(/*Could not decode attribute arguments.*/)]
		private void SetupLockersClientRpc(bool[] lockerStates)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Invalid comparison between Unknown and I4
			//IL_0043: 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_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1)
			{
				RpcAttributeParams val = default(RpcAttributeParams);
				RpcParams val3 = default(RpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendRpc(1629913294u, val3, val, (SendTo)7, (RpcDelivery)0);
				bool flag = lockerStates != null;
				((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				if (flag)
				{
					((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(lockerStates, default(ForPrimitives));
				}
				((NetworkBehaviour)this).__endSendRpc(ref val2, 1629913294u, val3, val, (SendTo)7, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1)
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				for (int i = 0; i < lockers.Length; i++)
				{
					((Component)lockers[i]).gameObject.SetActive(lockerStates[i]);
				}
			}
		}

		private IEnumerator DelugeFloodEvent()
		{
			if ((Object)(object)DelugePumpAudio != (Object)null)
			{
				if ((Object)(object)delugePumpWhir != (Object)null)
				{
					DelugePumpAudio.PlayOneShot(delugePumpWhir);
				}
				DelugePumpAudio.clip = delugeFlow;
				DelugePumpAudio.Play();
				DelugePumpAudio.loop = true;
			}
			if (controlRoomLights != null)
			{
				GameObject[] array = controlRoomLights;
				foreach (GameObject obj in array)
				{
					if ((Object)(object)obj != (Object)null)
					{
						obj.SetActive(false);
					}
				}
			}
			if (miscClips != null && miscClips.Length != 0 && (Object)(object)miscClips[0] != (Object)null && (Object)(object)AmbienceAudio != (Object)null)
			{
				AmbienceAudio.clip = miscClips[0];
				AmbienceAudio.Play();
				if (MiscAudios != null && MiscAudios.Length > 1 && (Object)(object)MiscAudios[1] != (Object)null)
				{
					MiscAudios[1].clip = miscClips[0];
					MiscAudios[1].volume = 1f;
					((MonoBehaviour)this).StartCoroutine(StartAudioWithFade(MiscAudios[1], 0.5f));
				}
			}
			if ((Object)(object)PCAnimator != (Object)null)
			{
				PCAnimator.SetBool("DamActive", true);
			}
			yield return (object)new WaitForSeconds(1f);
			isRainingInside = true;
			if ((Object)(object)MonitorAudio != (Object)null && (Object)(object)monitorAlarmBeep != (Object)null)
			{
				MonitorAudio.PlayOneShot(monitorAlarmBeep);
			}
			if (controlRoomLights2 != null)
			{
				GameObject[] array2 = controlRoomLights2;
				foreach (GameObject obj2 in array2)
				{
					if ((Object)(object)obj2 != (Object)null)
					{
						obj2.SetActive(true);
					}
				}
			}
			BurstValve();
			yield return (object)new WaitForSeconds(1f);
			if (basinScrapSpawners != null)
			{
				foreach (ItemSpawner spawner in basinScrapSpawners)
				{
					if (!((Object)(object)spawner == (Object)null))
					{
						Debug.Log((object)"[ControlRoomManager] enabling scrap spawner.");
						((Behaviour)spawner).enabled = true;
						if ((Object)(object)((Component)spawner).gameObject != (Object)null)
						{
							((Component)spawner).gameObject.SetActive(true);
						}
					}
				}
			}
			else
			{
				Debug.LogWarning((object)"[ControlRoomManager] basinScrapSpawners is null on this client!");
			}
			yield return (object)new WaitForSeconds(0.25f);
			NamespacedKey<DawnItemInfo> itemKey = NamespacedKey<DawnItemInfo>.From("opalite_moon", "sopping_zed_dog");
			Item soppyzedProperties = null;
			if (LethalContent.Items != null && ((Registry<DawnItemInfo>)(object)LethalContent.Items).ContainsKey(itemKey))
			{
				DawnItemInfo lookupResult = ((Registry<DawnItemInfo>)(object)LethalContent.Items)[itemKey];
				if (lookupResult != null)
				{
					soppyzedProperties = lookupResult.Item;
				}
			}
			if ((Object)(object)soppyzedProperties != (Object)null)
			{
				GrabbableObject[] array3 = Object.FindObjectsByType<GrabbableObject>((FindObjectsInactive)1, (FindObjectsSortMode)0);
				foreach (GrabbableObject grabbableObject in array3)
				{
					if (!((Object)(object)grabbableObject == (Object)null) && !string.IsNullOrEmpty(((Object)grabbableObject).name) && ((Object)grabbableObject).name.Contains("SoppingZed"))
					{
						if (BasinRandom != null)
						{
							grabbableObject.floorYRot = BasinRandom.Next(360);
						}
						if ((Object)(object)grabbableObject.itemProperties != (Object)(object)soppyzedProperties)
						{
							grabbableObject.itemProperties = soppyzedProperties;
						}
					}
				}
			}
			drainTimer = 0f;
			if ((Object)(object)reservoirWaterAnimator != (Object)null)
			{
				reservoirWaterAnimator.SetBool("Drain", true);
				reservoirWaterAnimator.SetBool("Filled", false);
			}
			if ((Object)(object)HUDManager.Instance != (Object)null)
			{
				HUDManager.Instance.DisplayTip("???", "The dam's flood gate has opened.", false, false, "LC_Tip1");
			}
			yield return null;
		}

		public void BurstValve()
		{
			valve.valveHasBurst = true;
			valve.BurstValve();
		}

		private IEnumerator BigDoorOpen()
		{
			yield return (object)new WaitForSeconds(3f);
			garageDoorAnimator.SetBool("Open", true);
			DoorAudio.clip = doorOpeningSfx;
			DoorAudio.Play();
			yield return (object)new WaitForSeconds(2f);
			((MonoBehaviour)this).StartCoroutine(StopAudioAfterFade(DoorAudio, 0.5f));
		}

		private IEnumerator BigDoorClose()
		{
			yield return (object)new WaitForSeconds(1f);
			garageDoorAnimator.SetBool("Open", false);
		}

		public void InitExitListeners()
		{
			indoorDoorTrigger = ((Component)controlRoomTeleport).GetComponent<InteractTrigger>();
			controlRoomDoorTrigger = ((Component)outdoorControlRoomTeleport).GetComponent<InteractTrigger>();
			((UnityEvent<PlayerControllerB>)(object)controlRoomDoorTrigger.onInteract).AddListener((UnityAction<PlayerControllerB>)OutdoorControlRoomDoorTeleportPlayer);
			((UnityEvent<PlayerControllerB>)(object)indoorDoorTrigger.onInteract).AddListener((UnityAction<PlayerControllerB>)IndoorControlRoomDoorTeleportPlayer);
			OpaliteMoonPlugin.Log.LogDebug((object)"[ControlRoomManager] added event controlRoomTeleportAction to controlRoomFireTrigger.onInteract");
		}

		public void OutdoorControlRoomDoorTeleportPlayer(PlayerControllerB player)
		{
			OpaliteMoonPlugin.Log.LogDebug((object)$"[ControlRoomManager] Teleported from Outside -> ControlRoom. Teleport finished from local player {player.actualClientId}");
			UpdateControlRoomPresenceServerRpc(player.actualClientId, isEntering: true);
		}

		public void IndoorControlRoomDoorTeleportPlayer(PlayerControllerB player)
		{
			OpaliteMoonPlugin.Log.LogDebug((object)$"[ControlRoomManager] Teleported from ControlRoom -> Outside. Teleport finished from local player {player.actualClientId}");
			UpdateControlRoomPresenceServerRpc(player.actualClientId, isEntering: false);
		}

		[Rpc(/*Could not decode attribute arguments.*/)]
		private void UpdateControlRoomPresenceServerRpc(ulong clientId, bool isEntering)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Invalid comparison between Unknown and I4
			//IL_0043: 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_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: 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)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1)
				{
					RpcAttributeParams val = new RpcAttributeParams
					{
						RequireOwnership = false
					};
					RpcParams val3 = default(RpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendRpc(1116323371u, val3, val, (SendTo)2, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val2, clientId);
					((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref isEntering, default(ForPrimitives));
					((NetworkBehaviour)this).__endSendRpc(ref val2, 1116323371u, val3, val, (SendTo)2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1)
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					UpdateControlRoomPresenceClientRpc(clientId, isEntering);
				}
			}
		}

		public void LateUpdate()
		{
			//IL_018d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0193: Invalid comparison between Unknown and I4
			hasBeenPowered = dockHandler.isPowered;
			if (!isPoweredOld && hasBeenPowered)
			{
				OnBeginPowerServerRpc();
			}
			isPoweredOld = dockHandler.isPowered;
			if (isDraining && drainTimer < 1f)
			{
				drainTimer += Time.deltaTime / 42f;
				if (drainTimer > 1f)
				{
					drainTimer = 1f;
					isRainingInside = false;
					((MonoBehaviour)this).StartCoroutine(StopAudioAfterFade(AmbienceAudio, 0.5f));
					((MonoBehaviour)this).StartCoroutine(StopAudioAfterFade(MiscAudios[1], 0.5f));
				}
				reservoirWaterAnimator.SetFloat("Time", drainTimer);
			}
			if ((Object)(object)kyividAnimator != (Object)null)
			{
				kyividAnimator.SetFloat("timeOfDay", TimeOfDay.Instance.normalizedTimeOfDay);
			}
			if (StartOfRound.Instance.localPlayerController.isInsideFactory && isRainingInside)
			{
				TimeOfDay.Instance.effects[1].effectEnabled = true;
			}
			else if (StartOfRound.Instance.localPlayerController.isInsideFactory)
			{
				TimeOfDay.Instance.effects[1].effectEnabled = false;
			}
			else
			{
				TimeOfDay.Instance.effects[1].effectEnabled = (int)TimeOfDay.Instance.currentLevelWeather == 1;
			}
		}

		[Rpc(/*Could not decode attribute arguments.*/)]
		private void UpdateControlRoomPresenceClientRpc(ulong clientId, bool isEntering)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Invalid comparison between Unknown and I4
			//IL_0043: 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_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1)
			{
				RpcAttributeParams val = default(RpcAttributeParams);
				RpcParams val3 = default(RpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendRpc(3542651060u, val3, val, (SendTo)7, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val2, clientId);
				((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref isEntering, default(ForPrimitives));
				((NetworkBehaviour)this).__endSendRpc(ref val2, 3542651060u, val3, val, (SendTo)7, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage != 1)
			{
				return;
			}
			base.__rpc_exec_stage = (__RpcExecStage)0;
			ulong clientId2 = clientId;
			PlayerControllerB val4 = ((IEnumerable<PlayerControllerB>)StartOfRound.Instance.allPlayerScripts).FirstOrDefault((Func<PlayerControllerB, bool>)((PlayerControllerB p) => p.actualClientId == clientId2));
			if ((Object)(object)val4 == (Object)null)
			{
				return;
			}
			ControlRoomPlayerManager controlRoomPlayerManager = ((Component)val4).GetComponent<ControlRoomPlayerManager>();
			if ((Object)(object)controlRoomPlayerManager == (Object)null)
			{
				controlRoomPlayerManager = ((Component)val4).gameObject.AddComponent<ControlRoomPlayerManager>();
			}
			controlRoomPlayerManager.controlRoom = this;
			if (isEntering)
			{
				if (!playersInsideControlRoom.Contains(val4))
				{
					PlayerEnterControlRoom(val4);
					controlRoomPlayerManager.EnterControlRoom();
				}
			}
			else if (playersInsideControlRoom.Contains(val4))
			{
				PlayerExitControlRoom(val4);
				controlRoomPlayerManager.LeaveControlRoom();
			}
		}

		private void PlayerEnterControlRoom(PlayerControllerB player)
		{
			playersInsideControlRoom.Add(player);
			if ((Object)(object)player == (Object)(object)StartOfRound.Instance.localPlayerController)
			{
				AmbienceAudio.volume = 1f;
			}
			OpaliteMoonPlugin.Log.LogDebug((object)("[ControlRoomManager] Added " + player.playerUsername + " to Control Room"));
		}

		private void PlayerExitControlRoom(PlayerControllerB player)
		{
			playersInsideControlRoom.Remove(player);
			if ((Object)(object)player == (Object)(object)StartOfRound.Instance.localPlayerController)
			{
				AmbienceAudio.volume = 0f;
			}
			OpaliteMoonPlugin.Log.LogDebug((object)("[ControlRoomManager] Removed " + player.playerUsername + " from Control Room"));
		}

		public List<Renderer> GetActiveRenderers()
		{
			List<Renderer> list = ((Component)this).gameObject.GetComponentsInChildren<Renderer>().ToList();
			List<Renderer> list2 = new List<Renderer>();
			foreach (Renderer item in list)
			{
				if (item.enabled)
				{
					list2.Add(item);
				}
			}
			return list2;
		}

		public void CullControlRoom(bool cull)
		{
			foreach (Renderer renderer in renderers)
			{
				renderer.enabled = !cull;
			}
		}

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

		protected override void __initializeRpcs()
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Expected O, but got Unknown
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Expected O, but got Unknown
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Expected O, but got Unknown
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Expected O, but got Unknown
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Expected O, but got Unknown
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Expected O, but got Unknown
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Expected O, but got Unknown
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Expected O, but got Unknown
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Expected O, but got Unknown
			((NetworkBehaviour)this).__registerRpc(1399946006u, new RpcReceiveHandler(__rpc_handler_1399946006), "StartDelugeServerRpc");
			((NetworkBehaviour)this).__registerRpc(545389115u, new RpcReceiveHandler(__rpc_handler_545389115), "StartDelugeClientRpc");
			((NetworkBehaviour)this).__registerRpc(2799117281u, new RpcReceiveHandler(__rpc_handler_2799117281), "OnBeginPowerServerRpc");
			((NetworkBehaviour)this).__registerRpc(565277397u, new RpcReceiveHandler(__rpc_handler_565277397), "OnBeginPowerClientRpc");
			((NetworkBehaviour)this).__registerRpc(1133039509u, new RpcReceiveHandler(__rpc_handler_1133039509), "OnEndPowerClientRpc");
			((NetworkBehaviour)this).__registerRpc(228644649u, new RpcReceiveHandler(__rpc_handler_228644649), "SetupLockersServerRpc");
			((NetworkBehaviour)this).__registerRpc(1629913294u, new RpcReceiveHandler(__rpc_handler_1629913294), "SetupLockersClientRpc");
			((NetworkBehaviour)this).__registerRpc(1116323371u, new RpcReceiveHandler(__rpc_handler_1116323371), "UpdateControlRoomPresenceServerRpc");
			((NetworkBehaviour)this).__registerRpc(3542651060u, new RpcReceiveHandler(__rpc_handler_3542651060), "UpdateControlRoomPresenceClientRpc");
			((NetworkBehaviour)this).__initializeRpcs();
		}

		private static void __rpc_handler_1399946006(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((ControlRoomManager)(object)target).StartDelugeServerRpc();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_545389115(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((ControlRoomManager)(object)target).StartDelugeClientRpc();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2799117281(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((ControlRoomManager)(object)target).OnBeginPowerServerRpc();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_565277397(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((ControlRoomManager)(object)target).OnBeginPowerClientRpc();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1133039509(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((ControlRoomManager)(object)target).OnEndPowerClientRpc();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_228644649(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((ControlRoomManager)(object)target).SetupLockersServerRpc();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1629913294(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: 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_005e: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				bool flag = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
				bool[] lockerStates = null;
				if (flag)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref lockerStates, default(ForPrimitives));
				}
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((ControlRoomManager)(object)target).SetupLockersClientRpc(lockerStates);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

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

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

		protected internal override string __getTypeName()
		{
			return "ControlRoomManager";
		}
	}
	public class PlayerDetector : NetworkBehaviour
	{
		public bool triggerOnce = true;

		private bool triggeredOnce;

		public UnityEvent OnEnterTriggerEventsAllClients;

		public UnityEvent OnEnterTriggerEventsThisClient;

		public void OnTriggerEnter(Collider other)
		{
			PlayerControllerB localPlayerController = GameNetworkManager.Instance.localPlayerController;
			Debug.Log((object)"[PlayerDetector] something has collided at least...");
			if ((Object)(object)((Component)other).gameObject == (Object)(object)((Component)localPlayerController).gameObject && (!triggerOnce || !triggeredOnce))
			{
				TriggerEnteredServerRpc(localPlayerController.actualClientId);
				Debug.Log((object)("[PlayerDetector] Player " + ((Object)((Component)localPlayerController).gameObject).name + " has entered the trigger of " + ((Object)((Component)this).gameObject).name + " [ON CLIENT]"));
			}
		}

		[Rpc(/*Could not decode attribute arguments.*/)]
		public void TriggerEnteredServerRpc(ulong playerID)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Invalid comparison between Unknown and I4
			//IL_0043: 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_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1)
				{
					RpcAttributeParams val = new RpcAttributeParams
					{
						RequireOwnership = false
					};
					RpcParams val3 = default(RpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendRpc(3793893011u, val3, val, (SendTo)2, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val2, playerID);
					((NetworkBehaviour)this).__endSendRpc(ref val2, 3793893011u, val3, val, (SendTo)2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1)
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					TriggerEnteredClientRpc(playerID);
				}
			}
		}

		[Rpc(/*Could not decode attribute arguments.*/)]
		protected virtual void TriggerEnteredClientRpc(ulong playerID)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_0043: 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_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1)
			{
				RpcAttributeParams val = default(RpcAttributeParams);
				RpcParams val3 = default(RpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendRpc(1260019935u, val3, val, (SendTo)7, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val2, playerID);
				((NetworkBehaviour)this).__endSendRpc(ref val2, 1260019935u, val3, val, (SendTo)7, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage != 1)
			{
				return;
			}
			base.__rpc_exec_stage = (__RpcExecStage)0;
			PlayerControllerB val4 = null;
			PlayerControllerB[] allPlayerScripts = StartOfRound.Instance.allPlayerScripts;
			foreach (PlayerControllerB val5 in allPlayerScripts)
			{
				if (val5.actualClientId == playerID)
				{
					val4 = val5;
					break;
				}
			}
			if ((Object)(object)val4 == (Object)null)
			{
				OpaliteMoonPlugin.Log.LogWarning((object)$"Could not find player with ID {playerID}");
				return;
			}
			triggeredOnce = true;
			Debug.Log((object)("Player " + ((Object)((Component)val4).gameObject).name + " has entered the trigger of " + ((Object)((Component)this).gameObject).name + " [ALL CLIENTS]"));
			OpaliteMoonPlugin.Log.LogDebug((object)("Player " + ((Object)((Component)val4).gameObject).name + " has entered the trigger of " + ((Object)((Component)this).gameObject).name + " [ALL CLIENTS]"));
			OnEnterTriggerEventsAllClients.Invoke();
			if ((Object)(object)StartOfRound.Instance.localPlayerController == (Object)(object)val4)
			{
				OnEnterTriggerEventsThisClient.Invoke();
			}
		}

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

		protected override void __initializeRpcs()
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Expected O, but got Unknown
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Expected O, but got Unknown
			((NetworkBehaviour)this).__registerRpc(3793893011u, new RpcReceiveHandler(__rpc_handler_3793893011), "TriggerEnteredServerRpc");
			((NetworkBehaviour)this).__registerRpc(1260019935u, new RpcReceiveHandler(__rpc_handler_1260019935), "TriggerEnteredClientRpc");
			((NetworkBehaviour)this).__initializeRpcs();
		}

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

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

		protected internal override string __getTypeName()
		{
			return "PlayerDetector";
		}
	}
	public class ControlRoomPlayerManager : MonoBehaviour
	{
		public PlayerControllerB player;

		public ControlRoomManager controlRoom;

		public void Awake()
		{
			PlayerExists();
		}

		public void EnterControlRoom()
		{
			if (PlayerExists() && !((Object)(object)player != (Object)(object)StartOfRound.Instance.localPlayerController))
			{
				player.isInsideFactory = true;
				if ((Object)(object)KyividManager.Instance != (Object)null && (Object)(object)KyividManager.Instance.kyividDirectionalLighting != (Object)null)
				{
					((Behaviour)KyividManager.Instance.kyividDirectionalLighting).enabled = false;
				}
			}
		}

		public void LeaveControlRoom()
		{
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Invalid comparison between Unknown and I4
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			if (PlayerExists() && !((Object)(object)player != (Object)(object)StartOfRound.Instance.localPlayerController))
			{
				player.isInsideFactory = false;
				if ((int)TimeOfDay.Instance.currentLevelWeather >= 0)
				{
					TimeOfDay.Instance.effects[TimeOfDay.Instance.currentLevelWeather].effectEnabled = true;
				}
				if ((Object)(object)KyividManager.Instance != (Object)null && (Object)(object)KyividManager.Instance.kyividDirectionalLighting != (Object)null)
				{
					((Behaviour)KyividManager.Instance.kyividDirectionalLighting).enabled = true;
				}
			}
		}

		private bool PlayerExists()
		{
			if ((Object)(object)player == (Object)null)
			{
				player = ((Component)this).GetComponent<PlayerControllerB>();
			}
			if ((Object)(object)player == (Object)null)
			{
				Object.Destroy((Object)(object)this);
				return false;
			}
			return true;
		}
	}
	public class ControlRoomSteamValve : MonoBehaviour
	{
		public float valveCrackTime;

		public float valveBurstTime;

		public bool valveHasBurst;

		private bool valveHasCracked;

		private bool valveHasBeenRepaired;

		public InteractTrigger triggerScript;

		[Header("Fog")]
		public Animator fogAnimator;

		public Animator valveAnimator;

		public float fogSizeMultiplier;

		public float currentFogSize;

		[Header("Other Effects")]
		public ParticleSystem valveSteamParticle;

		public AudioClip[] pipeFlowingSFX;

		public AudioClip valveTwistSFX;

		public AudioClip valveBurstSFX;

		public AudioClip valveCrackSFX;

		public AudioClip steamBlowSFX;

		public AudioSource valveAudio;

		public GameObject spawnParticleWhenCracked;

		public ControlRoomSteamValveFixInteraction fixInteract;

		private const string steamHUDWarningText = "VISIBILITY LOW!\n\nSteam leak detected in area";

		private void Start()
		{
			if (pipeFlowingSFX.Length != 0)
			{
				valveAudio.pitch = Random.Range(0.85f, 1.1f);
				valveAudio.clip = pipeFlowingSFX[Random.Range(0, pipeFlowingSFX.Length)];
				valveAudio.Play();
			}
		}

		private void Update()
		{
			//IL_0140: Unknown result type (might be due to invalid IL or missing references)
			//IL_0150: Unknown result type (might be due to invalid IL or missing references)
			if (StartOfRound.Instance.allPlayersDead || (Object)(object)NetworkManager.Singleton == (Object)null || !GameNetworkManager.Instance.gameHasStarted)
			{
				return;
			}
			if (valveHasBeenRepaired)
			{
				currentFogSize = Mathf.Clamp(currentFogSize - Time.deltaTime / 4f, 0.01f, 1f * fogSizeMultiplier);
				fogAnimator.SetFloat("time", currentFogSize);
			}
			else if (!valveHasCracked && valveCrackTime > 0f && TimeOfDay.Instance.normalizedTimeOfDay > valveCrackTime)
			{
				valveHasCracked = true;
				CrackValve();
			}
			else if (valveHasBurst && (Object)(object)fogAnimator != (Object)null)
			{
				currentFogSize = Mathf.Clamp(currentFogSize + Time.deltaTime / 12f, 0f, 1f * fogSizeMultiplier);
				fogAnimator.SetFloat("time", currentFogSize);
				if (Vector3.Distance(((Component)GameNetworkManager.Instance.localPlayerController).transform.position, ((Component)valveAudio).transform.position) < 10f)
				{
					HUDManager.Instance.increaseHelmetCondensation = true;
					HUDManager.Instance.DisplayStatusEffect("VISIBILITY LOW!\n\nSteam leak detected in area");
				}
			}
		}

		private void CrackValve()
		{
			//IL_0041: 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)
			valveAudio.PlayOneShot(valveCrackSFX);
			WalkieTalkie.TransmitOneShotAudio(valveAudio, valveCrackSFX, 1f);
			if ((Object)(object)valveSteamParticle != (Object)null)
			{
				MainModule main = valveSteamParticle.main;
				((MainModule)(ref main)).loop = false;
				valveSteamParticle.Play();
			}
		}

		public void BurstValve()
		{
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)spawnParticleWhenCracked != (Object)null)
			{
				Object.Instantiate<GameObject>(spawnParticleWhenCracked, ((Component)this).transform.position, Quaternion.identity, RoundManager.Instance.mapPropsContainer.transform);
				Object.Destroy((Object)(object)((Component)this).gameObject);
				return;
			}
			MainModule main = valveSteamParticle.main;
			((MainModule)(ref main)).loop = true;
			valveSteamParticle.Play();
			valveAudio.clip = steamBlowSFX;
			valveAudio.Play();
			valveAudio.PlayOneShot(valveBurstSFX);
			WalkieTalkie.TransmitOneShotAudio(valveAudio, valveBurstSFX, 1f);
			if ((Object)(object)triggerScript != (Object)null)
			{
				triggerScript.interactable = true;
			}
		}

		public void FixValveLocalClient()
		{
			if (valveHasBurst && !valveHasBeenRepaired)
			{
				valveSteamParticle.Stop(true, (ParticleSystemStopBehavior)1);
				valveAudio.clip = pipeFlowingSFX[Random.Range(0, pipeFlowingSFX.Length)];
				valveAudio.Play();
				valveAudio.PlayOneShot(valveTwistSFX, 1f);
				WalkieTalkie.TransmitOneShotAudio(valveAudio, valveTwistSFX, 1f);
				valveAnimator.SetTrigger("TwistValve");
				valveHasBeenRepaired = true;
				triggerScript.interactable = false;
			}
		}

		public void FixValve()
		{
			fixInteract.FixValve();
		}
	}
	public class ControlRoomSteamValveFixInteraction : NetworkBehaviour
	{
		public ControlRoomSteamValve steamValveMain;

		public void FixValve()
		{
			steamValveMain.FixValveLocalClient();
			if (((NetworkBehaviour)this).IsServer)
			{
				FixValveClientRpc();
			}
			else
			{
				FixValveServerRpc();
			}
		}

		[Rpc(/*Could not decode attribute arguments.*/)]
		public void FixValveServerRpc()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Invalid comparison between Unknown and I4
			//IL_0043: 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_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1)
				{
					RpcAttributeParams val = new RpcAttributeParams
					{
						RequireOwnership = false
					};
					RpcParams val3 = default(RpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendRpc(1910100652u, val3, val, (SendTo)2, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendRpc(ref val2, 1910100652u, val3, val, (SendTo)2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1)
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					FixValveClientRpc();
				}
			}
		}

		[Rpc(/*Could not decode attribute arguments.*/)]
		public void FixValveClientRpc()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_0043: 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_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1)
				{
					RpcAttributeParams val = default(RpcAttributeParams);
					RpcParams val3 = default(RpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendRpc(1472984272u, val3, val, (SendTo)7, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendRpc(ref val2, 1472984272u, val3, val, (SendTo)7, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1)
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					steamValveMain.FixValveLocalClient();
				}
			}
		}

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

		protected override void __initializeRpcs()
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Expected O, but got Unknown
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Expected O, but got Unknown
			((NetworkBehaviour)this).__registerRpc(1910100652u, new RpcReceiveHandler(__rpc_handler_1910100652), "FixValveServerRpc");
			((NetworkBehaviour)this).__registerRpc(1472984272u, new RpcReceiveHandler(__rpc_handler_1472984272), "FixValveClientRpc");
			((NetworkBehaviour)this).__initializeRpcs();
		}

		private static void __rpc_handler_1910100652(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((ControlRoomSteamValveFixInteraction)(object)target).FixValveServerRpc();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1472984272(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((ControlRoomSteamValveFixInteraction)(object)target).FixValveClientRpc();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		protected internal override string __getTypeName()
		{
			return "ControlRoomSteamValveFixInteraction";
		}
	}
	public class ControlRoomTeleport : NetworkBehaviour
	{
		public bool isEntranceToControlRoom;

		private bool jinglePlayed;

		public Transform entrancePoint;

		public int entranceId;

		public StartOfRound playersManager;

		public AudioClip customFirstTimeAudio;

		public int audioReverbPreset = -1;

		public ControlRoomTeleport exitScript;

		public AudioSource entrancePointAudio;

		public AudioClip[] doorAudios;

		public InteractTrigger triggerScript;

		private float checkForEnemiesInterval;

		private bool enemyNearLastCheck;

		private bool gotExitPoint;

		private bool checkedForFirstTime;

		public float timeAtLastUse;

		public Animator thisEntranceAnimator;

		private bool exitPointDoesntExist;

		private bool playingCreakAudio;

		public List<Light> dayLights;

		private void Awake()
		{
			playersManager = Object.FindObjectOfType<StartOfRound>();
			triggerScript = ((Component)this).gameObject.GetComponent<InteractTrigger>();
			checkForEnemiesInterval = 10f;
		}

		private void PlayCreakSFX()
		{
			AudioClip[] creakOpenDoorMetal = StartOfRound.Instance.creakOpenDoorMetal;
			int num = Random.Range(0, creakOpenDoorMetal.Length);
			entrancePointAudio.clip = creakOpenDoorMetal[num];
			entrancePointAudio.pitch = Random.Range(0.94f, 1.06f);
			entrancePointAudio.Play();
			playingCreakAudio = true;
			if ((Object)(object)exitScript != (Object)null && (Object)(object)exitScript.thisEntranceAnimator != (Object)null)
			{
				creakOpenDoorMetal = StartOfRound.Instance.creakOpenDoorMetal;
				exitScript.entrancePointAudio.clip = creakOpenDoorMetal[num];
				exitScript.entrancePointAudio.pitch = Random.Range(0.94f, 1.06f);
				exitScript.entrancePointAudio.Play();
			}
		}

		public void StartOpeningEntrance()
		{
			if (!GetDoorAnimators() || Time.realtimeSinceStartup - timeAtLastUse < 0.5f)
			{
				return;
			}
			if ((Object)(object)exitScript == (Object)null && (exitPointDoesntExist || !FindExitPoint()))
			{
				exitPointDoesntExist = true;
				return;
			}
			thisEntranceAnimator.SetBool("Open", true);
			if (!playingCreakAudio)
			{
				PlayCreakSFX();
			}
			if ((Object)(object)exitScript.thisEntranceAnimator != (Object)null)
			{
				exitScript.thisEntranceAnimator.SetBool("Open", true);
			}
			SyncStartOpeningDoorRpc();
		}

		[Rpc(/*Could not decode attribute arguments.*/)]
		public void SyncStartOpeningDoorRpc()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Invalid comparison between Unknown and I4
			//IL_0043: 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_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1)
			{
				RpcAttributeParams val = new RpcAttributeParams
				{
					RequireOwnership = false
				};
				RpcParams val3 = default(RpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendRpc(1335629203u, val3, val, (SendTo)5, (RpcDelivery)0);
				((NetworkBehaviour)this).__endSendRpc(ref val2, 1335629203u, val3, val, (SendTo)5, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage != 1)
			{
				return;
			}
			base.__rpc_exec_stage = (__RpcExecStage)0;
			if (!GetDoorAnimators())
			{
				return;
			}
			if ((Object)(object)exitScript == (Object)null && (exitPointDoesntExist || !FindExitPoint()))
			{
				exitPointDoesntExist = true;
				return;
			}
			thisEntranceAnimator.SetBool("Open", true);
			OpaliteMoonPlugin.Log.LogDebug((object)$"'{((Object)((Component)this).gameObject).name}' entrancePointAudio isPlaying: {entrancePointAudio.isPlaying}");
			if (!playingCreakAudio)
			{
				PlayCreakSFX();
			}
			if ((Object)(object)exitScript.thisEntranceAnimator != (Object)null)
			{
				exitScript.thisEntranceAnimator.SetBool("Open", true);
			}
		}

		public void FinishOpeningEntrance(bool playShutAudio = true)
		{
			OpaliteMoonPlugin.Log.LogDebug((object)$"Called finishopeningentrance ({playShutAudio})");
			if (entranceId != 0)
			{
				OpaliteMoonPlugin.Log.LogDebug((object)"Id is not 0");
				return;
			}
			if (!GetDoorAnimators())
			{
				OpaliteMoonPlugin.Log.LogDebug((object)"finishopeningentrance animator null");
				return;
			}
			if (!thisEntranceAnimator.GetBool("Open"))
			{
				if (playingCreakAudio)
				{
					entrancePointAudio.Stop();
					if ((Object)(object)exitScript != (Object)null && (Object)(object)exitScript.thisEntranceAnimator != (Object)null)
					{
						exitScript.entrancePointAudio.Stop();
					}
				}
				OpaliteMoonPlugin.Log.LogDebug((object)"Entrance teleport was not open; returning");
				return;
			}
			if ((Object)(object)exitScript == (Object)null && (exitPointDoesntExist || !FindExitPoint()))
			{
				OpaliteMoonPlugin.Log.LogDebug((object)"Couldn't find exit script");
				exitPointDoesntExist = true;
				OpaliteMoonPlugin.Log.LogDebug((object)"End A");
				return;
			}
			thisEntranceAnimator.SetBool("Open", false);
			OpaliteMoonPlugin.Log.LogDebug((object)("'" + ((Object)((Component)this).gameObject).name + "' STOPPING entrancePointAudio"));
			entrancePointAudio.Stop();
			playingCreakAudio = false;
			if ((Object)(object)exitScript.thisEntranceAnimator != (Object)null)
			{
				exitScript.entrancePointAudio.Stop();
			}
			if (playShutAudio)
			{
				if (Time.realtimeSinceStartup - timeAtLastUse > 0.5f)
				{
					PlayAudioAtTeleportPositions();
				}
				SyncFinishOpeningEntranceRpc();
			}
			if ((Object)(object)exitScript.thisEntranceAnimator != (Object)null)
			{
				exitScript.thisEntranceAnimator.SetBool("Open", false);
			}
		}

		[Rpc(/*Could not decode attribute arguments.*/)]
		public void SyncFinishOpeningEntranceRpc()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Invalid comparison between Unknown and I4
			//IL_0043: 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_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1)
			{
				RpcAttributeParams val = new RpcAttributeParams
				{
					RequireOwnership = false
				};
				RpcParams val3 = default(RpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendRpc(452626664u, val3, val, (SendTo)5, (RpcDelivery)0);
				((NetworkBehaviour)this).__endSendRpc(ref val2, 452626664u, val3, val, (SendTo)5, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage != 1)
			{
				return;
			}
			base.__rpc_exec_stage = (__RpcExecStage)0;
			if (entranceId != 0 || !GetDoorAnimators())
			{
				return;
			}
			if ((Object)(object)exitScript == (Object)null && (exitPointDoesntExist || !FindExitPoint()))
			{
				exitPointDoesntExist = true;
				return;
			}
			thisEntranceAnimator.SetBool("Open", false);
			entrancePointAudio.Stop();
			playingCreakAudio = false;
			if ((Object)(object)exitScript.thisEntranceAnimator != (Object)null)
			{
				exitScript.entrancePointAudio.Stop();
			}
			if (Time.realtimeSinceStartup - timeAtLastUse > 0.5f)
			{
				PlayAudioAtTeleportPositions();
			}
			if ((Object)(object)exitScript.thisEntranceAnimator != (Object)null)
			{
				exitScript.thisEntranceAnimator.SetBool("Open", false);
			}
		}

		private bool GetDoorAnimators()
		{
			return (Object)(object)thisEntranceAnimator != (Object)null;
		}

		public bool FindExitPoint()
		{
			ControlRoomTeleport[] array = Object.FindObjectsOfType<ControlRoomTeleport>();
			for (int i = 0; i < array.Length; i++)
			{
				if (array[i].isEntranceToControlRoom != isEntranceToControlRoom && array[i].entranceId == entranceId)
				{
					exitScript = array[i];
				}
			}
			if ((Object)(object)exitScript == (Object)null)
			{
				return false;
			}
			return true;
		}

		public void TeleportPlayer()
		{
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			bool flag = false;
			if (!FindExitPoint())
			{
				flag = true;
			}
			if (flag)
			{
				HUDManager.Instance.DisplayTip("???", "The entrance appears to be blocked.", false, false, "LC_Tip1");
				return;
			}
			PlayerControllerB localPlayerController = GameNetworkManager.Instance.localPlayerController;
			Transform thisPlayerBody = localPlayerController.thisPlayerBody;
			localPlayerController.TeleportPlayer(exitScript.entrancePoint.position, false, 0f, false, true);
			localPlayerController.isInElevator = false;
			localPlayerController.isInHangarShipRoom = false;
			thisPlayerBody.eulerAngles = new Vector3(thisPlayerBody.eulerAngles.x, exitScript.entrancePoint.eulerAngles.y, thisPlayerBody.eulerAngles.z);
			localPlayerController.isInsideFactory = isEntranceToControlRoom;
			for (int i = 0; i < localPlayerController.ItemSlots.Length; i++)
			{
				if ((Object)(object)localPlayerController.ItemSlots[i] != (Object)null)
				{
					localPlayerController.ItemSlots[i].isInFactory = isEntranceToControlRoom;
				}
			}
			if ((Object)(object)localPlayerController.ItemOnlySlot != (Object)null)
			{
				localPlayerController.ItemOnlySlot.isInFactory = isEntranceToControlRoom;
			}
			FinishOpeningEntrance(playShutAudio: false);
			SetAudioPreset((int)GameNetworkManager.Instance.localPlayerController.playerClientId);
			if (!checkedForFirstTime && isEntranceToControlRoom)
			{
				checkedForFirstTime = true;
				((MonoBehaviour)this).StartCoroutine(playMusicOnDelay());
			}
			timeAtLastUse = Time.realtimeSinceStartup;
			TeleportPlayerServerRpc((int)GameNetworkManager.Instance.localPlayerController.playerClientId);
			GameNetworkManager.Instance.localPlayerController.isInsideFactory = isEntranceToControlRoom;
		}

		private IEnumerator playMusicOnDelay()
		{
			yield return (object)new WaitForSeconds(0.6f);
			if (Random.value < 0.33f)
			{
				HUDManager.Instance.UIAudio.PlayOneShot(customFirstTimeAudio);
			}
		}

		[Rpc(/*Could not decode attribute arguments.*/)]
		public void TeleportPlayerServerRpc(int playerObj)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Invalid comparison between Unknown and I4
			//IL_0043: 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_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1)
				{
					RpcAttributeParams val = new RpcAttributeParams
					{
						RequireOwnership = false
					};
					RpcParams val3 = default(RpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendRpc(3311477417u, val3, val, (SendTo)2, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val2, playerObj);
					((NetworkBehaviour)this).__endSendRpc(ref val2, 3311477417u, val3, val, (SendTo)2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1)
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					TeleportPlayerClientRpc(playerObj);
				}
			}
		}

		[Rpc(/*Could not decode attribute arguments.*/)]
		public void TeleportPlayerClientRpc(int playerObj)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_0043: 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_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1)
			{
				RpcAttributeParams val = default(RpcAttributeParams);
				RpcParams val3 = default(RpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendRpc(1074452767u, val3, val, (SendTo)7, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val2, playerObj);
				((NetworkBehaviour)this).__endSendRpc(ref val2, 1074452767u, val3, val, (SendTo)7, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage != 1)
			{
				return;
			}
			base.__rpc_exec_stage = (__RpcExecStage)0;
			if ((Object)(object)playersManager.allPlayerScripts[playerObj] == (Object)(object)GameNetworkManager.Instance.localPlayerController || !FindExitPoint())
			{
				return;
			}
			playersManager.allPlayerScripts[playerObj].TeleportPlayer(exitScript.entrancePoint.position, true, exitScript.entrancePoint.eulerAngles.y, false, true);
			playersManager.allPlayerScripts[playerObj].isInElevator = false;
			playersManager.allPlayerScripts[playerObj].isInHangarShipRoom = false;
			PlayerControllerB val4 = playersManager.allPlayerScripts[playerObj];
			if ((Object)(object)val4 == (Object)null || (Object)(object)val4 == (Object)(object)GameNetworkManager.Instance.localPlayerController)
			{
				return;
			}
			val4.isInsideFactory = isEntranceToControlRoom;
			for (int i = 0; i < val4.ItemSlots.Length; i++)
			{
				if ((Object)(object)val4.ItemSlots[i] != (Object)null)
				{
					val4.ItemSlots[i].isInFactory = isEntranceToControlRoom;
				}
			}
			if ((Object)(object)val4.ItemOnlySlot != (Object)null)
			{
				val4.ItemOnlySlot.isInFactory = isEntranceToControlRoom;
			}
			FinishOpeningEntrance(playShutAudio: false);
			playersManager.allPlayerScripts[playerObj].isInsideFactory = isEntranceToControlRoom;
			if (GameNetworkManager.Instance.localPlayerController.isPlayerDead && (Object)(object)playersManager.allPlayerScripts[playerObj] == (Object)(object)GameNetworkManager.Instance.localPlayerController.spectatedPlayerScript)
			{
				SetAudioPreset(playerObj);
			}
			else
			{
				PlayAudioAtTeleportPositions();
			}
			timeAtLastUse = Time.realtimeSinceStartup;
		}

		private void SetAudioPreset(int playerObj)
		{
			if (audioReverbPreset < 0)
			{
				return;
			}
			Object.FindObjectOfType<AudioReverbPresets>().audioPresets[audioReverbPreset].ChangeAudioReverbForPlayer(StartOfRound.Instance.allPlayerScripts[playerObj]);
			AudioReverbPresets val = Object.FindObjectOfType<AudioReverbPresets>();
			if (!((Object)(object)val == (Object)null) && val.audioPresets != null && audioReverbPreset < val.audioPresets.Length)
			{
				PlayerControllerB val2 = StartOfRound.Instance.allPlayerScripts[playerObj];
				val.audioPresets[audioReverbPreset].ChangeAudioReverbForPlayer(val2);
				if ((Object)(object)entrancePointAudio != (Object)null)
				{
					PlayAudioAtTeleportPositions();
				}
			}
		}

		public void PlayAudioAtTeleportPositions()
		{
			if ((Object)(object)StartOfRound.Instance.testRoom != (Object)null)
			{
				return;
			}
			if (entranceId == 0)
			{
				AudioClip[] shutDoorMetal = StartOfRound.Instance.shutDoorMetal;
				AudioClip[] shutDoorMetal2 = StartOfRound.Instance.shutDoorMetal;
				if (isEntranceToControlRoom)
				{
					entrancePointAudio.pitch = Random.Range(0.94f, 1.06f);
					entrancePointAudio.PlayOneShot(shutDoorMetal[Random.Range(0, shutDoorMetal.Length)]);
					exitScript.entrancePointAudio.pitch = Random.Range(0.94f, 1.06f);
					exitScript.entrancePointAudio.PlayOneShot(shutDoorMetal2[Random.Range(0, shutDoorMetal2.Length)]);
				}
				else
				{
					entrancePointAudio.pitch = Random.Range(0.94f, 1.06f);
					entrancePointAudio.PlayOneShot(shutDoorMetal2[Random.Range(0, shutDoorMetal2.Length)]);
					exitScript.entrancePointAudio.pitch = Random.Range(0.94f, 1.06f);
					exitScript.entrancePointAudio.PlayOneShot(shutDoorMetal[Random.Range(0, shutDoorMetal.Length)]);
				}
			}
			else if (doorAudios.Length != 0)
			{
				entrancePointAudio.pitch = Random.Range(0.94f, 1.06f);
				entrancePointAudio.PlayOneShot(doorAudios[Random.Range(0, doorAudios.Length)]);
				exitScript.entrancePointAudio.pitch = Random.Range(0.94f, 1.06f);
				exitScript.entrancePointAudio.PlayOneShot(doorAudios[Random.Range(0, doorAudios.Length)]);
			}
		}

		private void Update()
		{
			//IL_008e: 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)
			if ((Object)(object)triggerScript == (Object)null || !isEntranceToControlRoom)
			{
				return;
			}
			if (checkForEnemiesInterval <= 0f)
			{
				if (!gotExitPoint)
				{
					if (FindExitPoint())
					{
						gotExitPoint = true;
					}
					return;
				}
				checkForEnemiesInterval = 1f;
				bool flag = false;
				for (int i = 0; i < RoundManager.Instance.SpawnedEnemies.Count; i++)
				{
					if (Vector3.Distance(((Component)RoundManager.Instance.SpawnedEnemies[i]).transform.position, ((Component)exitScript.entrancePoint).transform.position) < 7.7f && !RoundManager.Instance.SpawnedEnemies[i].isEnemyDead)
					{
						flag = true;
						break;
					}
				}
				if (flag && !enemyNearLastCheck)
				{
					enemyNearLastCheck = true;
					triggerScript.hoverTip = "[Near activity detected!]";
				}
				else if (enemyNearLastCheck)
				{
					enemyNearLastCheck = false;
					triggerScript.hoverTip = "Enter: [LMB]";
				}
			}
			else
			{
				checkForEnemiesInterval -= Time.deltaTime;
			}
		}

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

		protected override void __initializeRpcs()
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Expected O, but got Unknown
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Expected O, but got Unknown
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Expected O, but got Unknown
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Expected O, but got Unknown
			((NetworkBehaviour)this).__registerRpc(1335629203u, new RpcReceiveHandler(__rpc_handler_1335629203), "SyncStartOpeningDoorRpc");
			((NetworkBehaviour)this).__registerRpc(452626664u, new RpcReceiveHandler(__rpc_handler_452626664), "SyncFinishOpeningEntranceRpc");
			((NetworkBehaviour)this).__registerRpc(3311477417u, new RpcReceiveHandler(__rpc_handler_3311477417), "TeleportPlayerServerRpc");
			((NetworkBehaviour)this).__registerRpc(1074452767u, new RpcReceiveHandler(__rpc_handler_1074452767), "TeleportPlayerClientRpc");
			((NetworkBehaviour)this).__initializeRpcs();
		}

		private static void __rpc_handler_1335629203(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((ControlRoomTeleport)(object)target).SyncStartOpeningDoorRpc();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_452626664(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((ControlRoomTeleport)(object)target).SyncFinishOpeningEntranceRpc();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

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

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

		protected internal override string __getTypeName()
		{
			return "ControlRoomTeleport";
		}
	}
	public class FloodWaterZone : MonoBehaviour
	{
		public float vehicleForceMultiplier = 6f;

		public Transform sourcePos;

		public void OnTriggerStay(Collider other)
		{
			//IL_003a: 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_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: 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_00a2: 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)
			PlayerControllerB localPlayerController = GameNetworkManager.Instance.localPlayerController;
			VehicleController val = default(VehicleController);
			if ((Object)(object)((Component)other).gameObject == (Object)(object)((Component)localPlayerController).gameObject && !localPlayerController.inVehicleAnimation && !localPlayerController.inSpecialInteractAnimation)
			{
				localPlayerController.externalForceAutoFade += CalcPushForce(((Component)localPlayerController).transform.position);
				localPlayerController.fallValue = -1f;
				localPlayerController.fallValueUncapped = -1f;
			}
			else if (((Component)other).gameObject.TryGetComponent<VehicleController>(ref val) && ((NetworkBehaviour)val).IsOwner)
			{
				val.mainRigidbody.AddForce(CalcPushForce(((Component)val).transform.position) * vehicleForceMultiplier, (ForceMode)1);
			}
		}

		public Vector3 CalcPushForce(Vector3 pos)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			return sourcePos.forward * 0.5f;
		}
	}
	public class KyividManager : MonoBehaviour
	{
		public Light kyividDirectionalLighting;

		public Transform lightTarget;

		public static KyividManager Instance;

		public void Awake()
		{
			if ((Object)(object)Instance == (Object)null)
			{
				Instance = this;
			}
		}

		public void Update()
		{
			if ((Object)(object)((Component)lightTarget).transform != (Object)null)
			{
				((Component)kyividDirectionalLighting).transform.LookAt(((Component)lightTarget).transform);
				if (StartOfRound.Instance.localPlayerController.isInsideFactory)
				{
					((Behaviour)kyividDirectionalLighting).enabled = false;
				}
			}
		}
	}
	[BepInPlugin("FlintChips.Contingency", "48_Contingency", "0.0.5")]
	public sealed class OpaliteMoonPlugin : BaseUnityPlugin
	{
		[HarmonyPatch(typeof(RoundManager))]
		[HarmonyPatch("LoadNewLevel")]
		public class SeedCheckPatch
		{
			[HarmonyPrefix]
			private static void Prefix(RoundManager __instance)
			{
				int randomMapSeed = StartOfRound.Instance.randomMapSeed;
				ControlRoomManager controlRoomManager = Object.FindFirstObjectByType<ControlRoomManager>();
				if ((Object)(object)controlRoomManager != (Object)null)
				{
					controlRoomManager.BeforeLoadNewLevel(randomMapSeed);
				}
				else
				{
					Debug.Log((object)"[SeedCheckPatch] ControlRoomManager not found!");
				}
				Debug.Log((object)$"[SeedCheckPatch] Prefix called before LoadNewLevel(), seed is {randomMapSeed}");
			}
		}

		public const string PluginGuid = "FlintChips.Contingency";

		public const string PluginName = "48_Contingency";

		public const string PluginVersion = "0.0.5";

		internal static ManualLogSource Log;

		private void Awake()
		{
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			Log = ((BaseUnityPlugin)this).Logger;
			AppDomain.CurrentDomain.AssemblyResolve += delegate(object sender, ResolveEventArgs args)
			{
				if (args.Name.Contains("OpaliteMod"))
				{
					Log.LogDebug((object)"[48contingency] Redirecting OpaliteMod to 48contingency!");
					return Assembly.GetExecutingAssembly();
				}
				return (Assembly)null;
			};
			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);
					}
				}
			}
			new Harmony("FlintChips.Contingency").PatchAll();
			((BaseUnityPlugin)this).Logger.LogInfo((object)"Loaded [FlintChips.Contingency v0.0.5]");
		}
	}
	public class RandomizedDropSoundObject : PhysicsProp
	{
		private int timesAudioDropped;

		public int playAfterTimesDropped = 0;

		public AudioClip rareDropSound;

		public float dropSoundChance = 0.11f;

		public override void PlayDropSFX()
		{
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)((GrabbableObject)this).itemProperties.dropSFX != (Object)null)
			{
				timesAudioDropped++;
				int seed = StartOfRound.Instance.randomMapSeed + (int)((NetworkBehaviour)this).NetworkObjectId + timesAudioDropped;
				Random random = new Random(seed);
				AudioClip val = (AudioClip)((random.NextDouble() <= (double)dropSoundChance && (Object)(object)rareDropSound != (Object)null && timesAudioDropped > playAfterTimesDropped) ? ((object)rareDropSound) : ((object)((GrabbableObject)this).itemProperties.dropSFX));
				AudioSource component = ((Component)this).gameObject.GetComponent<AudioSource>();
				component.PlayOneShot(val);
				WalkieTalkie.TransmitOneShotAudio(component, val, 1f);
				if (((NetworkBehaviour)this).IsOwner)
				{
					RoundManager.Instance.PlayAudibleNoise(((Component)this).transform.position, 8f, 0.5f, 0, ((GrabbableObject)this).isInElevator && StartOfRound.Instance.hangarDoorsClosed, 941);
				}
			}
			((GrabbableObject)this).hasHitGround = true;
		}

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

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

		protected internal override string __getTypeName()
		{
			return "RandomizedDropSoundObject";
		}
	}
	public class StartDelugeLever : NetworkBehaviour
	{
		public bool leverHasBeenPulled;

		public InteractTrigger triggerScript;

		public StartOfRound playersManager;

		public Animator leverAnimatorObject;

		private float updateInterval;

		private bool clientSentRPC;

		private Coroutine shakeCoroutine;

		public ControlRoomManager controlRoomManager;

		public void LeverAnimation()
		{
			if (!GameNetworkManager.Instance.localPlayerController.isPlayerDead && controlRoomManager.hasBeenPowered)
			{
				PullLeverAnim(leverPulled: true);
				clientSentRPC = true;
				SetStartingDelugeEffects();
				PlayLeverPullEffectsServerRpc(leverPulled: true);
			}
		}

		private void PullLeverAnim(bool leverPulled)
		{
			Debug.Log((object)$"Lever animation: setting bool to {leverPulled}");
			leverAnimatorObject.SetBool("pullLever", leverPulled);
			leverHasBeenPulled = leverPulled;
			triggerScript.interactable = false;
		}

		[Rpc(/*Could not decode attribute arguments.*/)]
		public void PlayLeverPullEffectsServerRpc(bool leverPulled)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Invalid comparison between Unknown and I4
			//IL_0043: 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_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1)
				{
					RpcAttributeParams val = new RpcAttributeParams
					{
						RequireOwnership = false
					};
					RpcParams val3 = default(RpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendRpc(3109614125u, val3, val, (SendTo)2, (RpcDelivery)0);
					((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref leverPulled, default(ForPrimitives));
					((NetworkBehaviour)this).__endSendRpc(ref val2, 3109614125u, val3, val, (SendTo)2, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1)
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					PlayLeverPullEffectsClientRpc(leverPulled);
				}
			}
		}

		[Rpc(/*Could not decode attribute arguments.*/)]
		private void PlayLeverPullEffectsClientRpc(bool leverPulled)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Invalid comparison between Unknown and I4
			//IL_0043: 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_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1)
			{
				RpcAttributeParams val = default(RpcAttributeParams);
				RpcParams val3 = default(RpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendRpc(1936330982u, val3, val, (SendTo)7, (RpcDelivery)0);
				((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref leverPulled, default(ForPrimitives));
				((NetworkBehaviour)this).__endSendRpc(ref val2, 1936330982u, val3, val, (SendTo)7, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1)
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				PullLeverAnim(leverPulled);
				if (leverPulled)
				{
					SetStartingDelugeEffects();
				}
			}
		}

		private void SetStartingDelugeEffects()
		{
			shakeCoroutine = ((MonoBehaviour)this).StartCoroutine(startShakeOnDelay());
		}

		private IEnumerator startShakeOnDelay()
		{
			yield return (object)new WaitForSeconds(2f);
			HUDManager.Instance.ShakeCamera((ScreenShakeType)4);
			yield return (object)new WaitForSeconds(30f);
			HUDManager.Instance.StopShakingCamera();
			shakeCoroutine = null;
		}

		public void CancelShakingEffects()
		{
			if (shakeCoroutine != null)
			{
				((MonoBehaviour)this).StopCoroutine(shakeCoroutine);
				shakeCoroutine = null;
			}
		}

		private void CancelStartingDelugeEffects()
		{
			if (shakeCoroutine != null)
			{
				((MonoBehaviour)this).StopCoroutine(shakeCoroutine);
				shakeCoroutine = null;
			}
			HUDManager.Instance.StopShakingCamera();
		}

		public void PullLever()
		{
			if (leverHasBeenPulled)
			{
				StartDeluge();
			}
		}

		public void StartDeluge()
		{
			OpaliteMoonPlugin.Log.LogDebug((object)"[StartDelugeLever] Start Deluge A");
			if (controlRoomManager.hasBeenPowered)
			{
				OpaliteMoonPlugin.Log.LogDebug((object)"[StartDelugeLever] Start Deluge successful");
				if ((Object)(object)controlRoomManager != (Object)null)
				{
					controlRoomManager.StartDelugeServerRpc();
					return;
				}
				triggerScript.hoverTip = "[ Failed. ]";
				updateInterval = 4f;
				CancelStartDeluge();
			}
		}

		[Rpc(/*Could not decode attribute arguments.*/)]
		public void CancelStartDelugeClientRpc()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_0043: 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_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1)
				{
					RpcAttributeParams val = default(RpcAttributeParams);
					RpcParams val3 = default(RpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendRpc(3214562234u, val3, val, (SendTo)7, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendRpc(ref val2, 3214562234u, val3, val, (SendTo)7, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1)
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					CancelStartDeluge();
				}
			}
		}

		private void CancelStartDeluge()
		{
			CancelStartingDelugeEffects();
			leverHasBeenPulled = false;
			leverAnimatorObject.SetBool("pullLever", false);
		}

		public void BeginHoldingInteractOnLever()
		{
		}

		private void Update()
		{
			if (updateInterval <= 0f)
			{
				updateInterval = 2f;
				if (!leverHasBeenPulled)
				{
					if (((NetworkBehaviour)this).IsServer || GameNetworkManager.Instance.gameHasStarted)
					{
						if (controlRoomManager.hasBeenPowered)
						{
							triggerScript.hoverTip = "Open Flood Gate : [LMB]";
						}
						else
						{
							triggerScript.hoverTip = "[Controls must be powered.]";
						}
					}
				}
				else
				{
					triggerScript.interactable = false;
					triggerScript.hoverTip = "[Locked]";
				}
			}
			else
			{
				updateInterval -= Time.deltaTime;
			}
		}

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

		protected override void __initializeRpcs()
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Expected O, but got Unknown
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Expected O, but got Unknown
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Expected O, but got Unknown
			((NetworkBehaviour)this).__registerRpc(3109614125u, new RpcReceiveHandler(__rpc_handler_3109614125), "PlayLeverPullEffectsServerRpc");
			((NetworkBehaviour)this).__registerRpc(1936330982u, new RpcReceiveHandler(__rpc_handler_1936330982), "PlayLeverPullEffectsClientRpc");
			((NetworkBehaviour)this).__registerRpc(3214562234u, new RpcReceiveHandler(__rpc_handler_3214562234), "CancelStartDelugeClientRpc");
			((NetworkBehaviour)this).__initializeRpcs();
		}

		private static void __rpc_handler_3109614125(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				bool leverPulled = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref leverPulled, default(ForPrimitives));
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((StartDelugeLever)(object)target).PlayLeverPullEffectsServerRpc(leverPulled);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1936330982(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				bool leverPulled = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref leverPulled, default(ForPrimitives));
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((StartDelugeLever)(object)target).PlayLeverPullEffectsClientRpc(leverPulled);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3214562234(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((StartDelugeLever)(object)target).CancelStartDelugeClientRpc();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		protected internal override string __getTypeName()
		{
			return "StartDelugeLever";
		}
	}
}
namespace __GEN
{
	internal class NetworkVariableSerializationHelper
	{
		[RuntimeInitializeOnLoadMethod]
		internal static void InitializeSerialization()
		{
		}
	}
}
namespace 48contingency.NetcodePatcher
{
	[AttributeUsage(AttributeTargets.Module)]
	internal class NetcodePatchedAssemblyAttribute : Attribute
	{
	}
}