Decompiled source of AnotherEntrance v0.1.1

plugins/AnotherEntrance/AnotherEntrance.dll

Decompiled an hour ago
using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using BepInEx;
using BepInEx.Configuration;
using GameNetcodeStuff;
using Microsoft.CodeAnalysis;
using Unity.Collections;
using Unity.Netcode;
using UnityEngine;
using UnityEngine.AI;
using UnityEngine.Events;
using UnityEngine.Rendering;
using UnityEngine.SceneManagement;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyVersion("0.0.0.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[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 AnotherEntrance
{
	[BepInPlugin("saltanis.anotherentrance", "Another Entrance", "0.1.1")]
	public sealed class EntrancePlugin : BaseUnityPlugin
	{
		private struct Hold
		{
			internal bool Entering;

			internal float Since;
		}

		private const string StateRequest = "saltanis.anotherentrance/v1/request";

		private const string StateMessage = "saltanis.anotherentrance/v1/state";

		private const string UseMessage = "saltanis.anotherentrance/v1/use";

		private const string TravelMessage = "saltanis.anotherentrance/v1/travel";

		private CustomMessagingManager messenger;

		private readonly Dictionary<ulong, Hold> holds = new Dictionary<ulong, Hold>();

		private readonly Dictionary<ulong, float> lastUse = new Dictionary<ulong, float>();

		private readonly Dictionary<ulong, float> lastStateRequest = new Dictionary<ulong, float>();

		private ulong useSequence;

		private ulong lastAppliedUse;

		internal const string Id = "saltanis.anotherentrance";

		internal const string Version = "0.1.1";

		private ConfigEntry<bool> enabledMod;

		private ConfigEntry<int> chance;

		private ConfigEntry<float> holdTime;

		private ConfigEntry<float> minimumDistance;

		private NetworkManager network;

		private EntranceWorld world;

		private EntranceState state;

		private Coroutine placing;

		private bool landing;

		private bool stateKnown;

		private ulong nextEpoch;

		private ulong minimumEpoch;

		private float nextPoll;

		private float nextRequest;

		private float localCooldown;

		internal static PlayerControllerB LocalPlayer
		{
			get
			{
				if (!Object.op_Implicit((Object)(object)GameNetworkManager.Instance))
				{
					return null;
				}
				return GameNetworkManager.Instance.localPlayerController;
			}
		}

		internal static bool Ready
		{
			get
			{
				StartOfRound instance = StartOfRound.Instance;
				RoundManager instance2 = RoundManager.Instance;
				if (Object.op_Implicit((Object)(object)instance) && ((NetworkBehaviour)instance).IsSpawned && instance.shipHasLanded && !instance.inShipPhase && !instance.shipIsLeaving && Object.op_Implicit((Object)(object)instance.currentLevel) && instance.currentLevel.spawnEnemiesAndScrap && Object.op_Implicit((Object)(object)instance2) && instance2.dungeonCompletedGenerating)
				{
					return !instance2.dungeonIsGenerating;
				}
				return false;
			}
		}

		private void BindMessages()
		{
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Expected O, but got Unknown
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Expected O, but got Unknown
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Expected O, but got Unknown
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Expected O, but got Unknown
			if (messenger == null && network.CustomMessagingManager != null)
			{
				messenger = network.CustomMessagingManager;
				if (network.IsServer)
				{
					messenger.RegisterNamedMessageHandler("saltanis.anotherentrance/v1/request", new HandleNamedMessageDelegate(ReceiveStateRequest));
					messenger.RegisterNamedMessageHandler("saltanis.anotherentrance/v1/use", new HandleNamedMessageDelegate(ReceiveUse));
					network.OnClientDisconnectCallback += ClientDisconnected;
				}
				else
				{
					messenger.RegisterNamedMessageHandler("saltanis.anotherentrance/v1/state", new HandleNamedMessageDelegate(ReceiveState));
					messenger.RegisterNamedMessageHandler("saltanis.anotherentrance/v1/travel", new HandleNamedMessageDelegate(ReceiveTravel));
				}
			}
		}

		private void UnbindMessages()
		{
			if (messenger != null)
			{
				messenger.UnregisterNamedMessageHandler("saltanis.anotherentrance/v1/request");
				messenger.UnregisterNamedMessageHandler("saltanis.anotherentrance/v1/state");
				messenger.UnregisterNamedMessageHandler("saltanis.anotherentrance/v1/use");
				messenger.UnregisterNamedMessageHandler("saltanis.anotherentrance/v1/travel");
				if (Object.op_Implicit((Object)(object)network))
				{
					network.OnClientDisconnectCallback -= ClientDisconnected;
				}
				messenger = null;
				lastStateRequest.Clear();
			}
		}

		private void ClientDisconnected(ulong id)
		{
			holds.Remove(id);
			lastUse.Remove(id);
			lastStateRequest.Remove(id);
		}

		private unsafe void RequestState()
		{
			//IL_0018: 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_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: 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)
			FastBufferWriter val = default(FastBufferWriter);
			((FastBufferWriter)(ref val))..ctor(8, (Allocator)2, -1);
			try
			{
				((FastBufferWriter)(ref val)).WriteValueSafe<int>(ref StartOfRound.Instance.randomMapSeed, default(ForPrimitives));
				((FastBufferWriter)(ref val)).WriteValueSafe<int>(ref StartOfRound.Instance.currentLevelID, default(ForPrimitives));
				messenger.SendNamedMessage("saltanis.anotherentrance/v1/request", 0uL, val, (NetworkDelivery)3);
			}
			finally
			{
				((IDisposable)(*(FastBufferWriter*)(&val))/*cast due to .constrained prefix*/).Dispose();
			}
		}

		private void ReceiveStateRequest(ulong sender, FastBufferReader reader)
		{
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			if (network.IsServer && Ready && stateKnown && ((FastBufferReader)(ref reader)).Length - ((FastBufferReader)(ref reader)).Position == 8 && network.ConnectedClients.ContainsKey(sender))
			{
				int num = default(int);
				((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref num, default(ForPrimitives));
				int num2 = default(int);
				((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref num2, default(ForPrimitives));
				if (num == state.Seed && num2 == state.Level && (!lastStateRequest.TryGetValue(sender, out var value) || !(Time.unscaledTime - value < 0.5f)))
				{
					lastStateRequest[sender] = Time.unscaledTime;
					SendState(sender);
				}
			}
		}

		private unsafe void SendState(ulong client)
		{
			//IL_0011: 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)
			FastBufferWriter val = default(FastBufferWriter);
			((FastBufferWriter)(ref val))..ctor(69, (Allocator)2, -1);
			try
			{
				state.Write(val);
				messenger.SendNamedMessage("saltanis.anotherentrance/v1/state", client, val, (NetworkDelivery)3);
			}
			finally
			{
				((IDisposable)(*(FastBufferWriter*)(&val))/*cast due to .constrained prefix*/).Dispose();
			}
		}

		private unsafe void BroadcastState()
		{
			//IL_0011: 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)
			FastBufferWriter val = default(FastBufferWriter);
			((FastBufferWriter)(ref val))..ctor(69, (Allocator)2, -1);
			try
			{
				state.Write(val);
				foreach (ulong connectedClientsId in network.ConnectedClientsIds)
				{
					if (connectedClientsId != network.LocalClientId)
					{
						messenger.SendNamedMessage("saltanis.anotherentrance/v1/state", connectedClientsId, val, (NetworkDelivery)3);
					}
				}
			}
			finally
			{
				((IDisposable)(*(FastBufferWriter*)(&val))/*cast due to .constrained prefix*/).Dispose();
			}
		}

		private void ReceiveState(ulong sender, FastBufferReader reader)
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			if (!network.IsServer && sender == 0L && Ready && ((FastBufferReader)(ref reader)).Length - ((FastBufferReader)(ref reader)).Position == 69)
			{
				EntranceState entranceState = EntranceState.Read(reader);
				StartOfRound instance = StartOfRound.Instance;
				if (entranceState.Valid && entranceState.Epoch > minimumEpoch && entranceState.Seed == instance.randomMapSeed && entranceState.Level == instance.currentLevelID && (!stateKnown || entranceState.Epoch > state.Epoch))
				{
					state = entranceState;
					landing = true;
					stateKnown = BuildWorld();
					((BaseUnityPlugin)this).Logger.LogInfo((object)("Received extra entrance for landing " + state.Epoch + ": " + state.Exists));
				}
			}
		}

		private unsafe void SendUse(ulong epoch, bool entering, byte action)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			FastBufferWriter val = default(FastBufferWriter);
			((FastBufferWriter)(ref val))..ctor(10, (Allocator)2, -1);
			try
			{
				((FastBufferWriter)(ref val)).WriteValueSafe<ulong>(ref epoch, default(ForPrimitives));
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref entering, default(ForPrimitives));
				((FastBufferWriter)(ref val)).WriteValueSafe<byte>(ref action, default(ForPrimitives));
				messenger.SendNamedMessage("saltanis.anotherentrance/v1/use", 0uL, val, (NetworkDelivery)3);
			}
			finally
			{
				((IDisposable)(*(FastBufferWriter*)(&val))/*cast due to .constrained prefix*/).Dispose();
			}
		}

		private void ReceiveUse(ulong sender, FastBufferReader reader)
		{
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			if (network.IsServer && ((FastBufferReader)(ref reader)).Length - ((FastBufferReader)(ref reader)).Position == 10 && network.ConnectedClients.ContainsKey(sender))
			{
				ulong epoch = default(ulong);
				((FastBufferReader)(ref reader)).ReadValueSafe<ulong>(ref epoch, default(ForPrimitives));
				bool entering = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref entering, default(ForPrimitives));
				byte action = default(byte);
				((FastBufferReader)(ref reader)).ReadValueSafe<byte>(ref action, default(ForPrimitives));
				HandleUse(sender, epoch, entering, action);
			}
		}

		private PlayerControllerB Player(ulong client)
		{
			StartOfRound instance = StartOfRound.Instance;
			if (Object.op_Implicit((Object)(object)instance))
			{
				PlayerControllerB[] allPlayerScripts = instance.allPlayerScripts;
				foreach (PlayerControllerB val in allPlayerScripts)
				{
					if (Object.op_Implicit((Object)(object)val) && val.isPlayerControlled && val.actualClientId == client)
					{
						return val;
					}
				}
			}
			return null;
		}

		private unsafe void HandleUse(ulong sender, ulong epoch, bool entering, byte action)
		{
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: 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_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_019d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0190: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0200: Unknown result type (might be due to invalid IL or missing references)
			//IL_0206: 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_0219: Unknown result type (might be due to invalid IL or missing references)
			//IL_0226: Unknown result type (might be due to invalid IL or missing references)
			//IL_022c: Unknown result type (might be due to invalid IL or missing references)
			//IL_026c: Unknown result type (might be due to invalid IL or missing references)
			if (!Ready || world == null || !stateKnown || !state.Exists || epoch != state.Epoch || action > 2)
			{
				return;
			}
			if (action == 2)
			{
				holds.Remove(sender);
				return;
			}
			PlayerControllerB val = Player(sender);
			Vector3 val2 = (entering ? state.OutsideHatch : (state.InsideFeet + Vector3.up));
			if (Object.op_Implicit((Object)(object)val) && !val.isPlayerDead && val.isInsideFactory != entering && !val.inSpecialInteractAnimation && !val.isClimbingLadder && !val.inTerminalMenu && !val.isInHangarShipRoom)
			{
				Vector3 val3 = ((Component)val).transform.position - val2;
				if (!(((Vector3)(ref val3)).sqrMagnitude > 18f) && (!lastUse.TryGetValue(sender, out var value) || !(Time.unscaledTime - value < 1.2f)))
				{
					if (action == 0)
					{
						holds[sender] = new Hold
						{
							Entering = entering,
							Since = Time.unscaledTime
						};
					}
					else
					{
						if (!holds.TryGetValue(sender, out var value2) || value2.Entering != entering || Time.unscaledTime - value2.Since < state.HoldTime - 0.2f || Time.unscaledTime - value2.Since > 30f)
						{
							return;
						}
						holds.Remove(sender);
						if (!EntrancePlacement.ClearLanding(entering ? state.InsideFeet : state.OutsideFeet))
						{
							return;
						}
						lastUse[sender] = Time.unscaledTime;
						ulong sequence = ++useSequence;
						ApplyTravel(sender, entering, sequence);
						FastBufferWriter val4 = default(FastBufferWriter);
						((FastBufferWriter)(ref val4))..ctor(25, (Allocator)2, -1);
						try
						{
							((FastBufferWriter)(ref val4)).WriteValueSafe<ulong>(ref epoch, default(ForPrimitives));
							((FastBufferWriter)(ref val4)).WriteValueSafe<ulong>(ref sender, default(ForPrimitives));
							((FastBufferWriter)(ref val4)).WriteValueSafe<bool>(ref entering, default(ForPrimitives));
							((FastBufferWriter)(ref val4)).WriteValueSafe<ulong>(ref sequence, default(ForPrimitives));
							foreach (ulong connectedClientsId in network.ConnectedClientsIds)
							{
								if (connectedClientsId != network.LocalClientId)
								{
									messenger.SendNamedMessage("saltanis.anotherentrance/v1/travel", connectedClientsId, val4, (NetworkDelivery)3);
								}
							}
							return;
						}
						finally
						{
							((IDisposable)(*(FastBufferWriter*)(&val4))/*cast due to .constrained prefix*/).Dispose();
						}
					}
					return;
				}
			}
			holds.Remove(sender);
		}

		private void ReceiveTravel(ulong sender, FastBufferReader reader)
		{
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: 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_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			if (!network.IsServer && sender == 0L && Ready && stateKnown && state.Exists && world != null && ((FastBufferReader)(ref reader)).Length - ((FastBufferReader)(ref reader)).Position == 25)
			{
				ulong num = default(ulong);
				((FastBufferReader)(ref reader)).ReadValueSafe<ulong>(ref num, default(ForPrimitives));
				ulong client = default(ulong);
				((FastBufferReader)(ref reader)).ReadValueSafe<ulong>(ref client, default(ForPrimitives));
				bool entering = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref entering, default(ForPrimitives));
				ulong sequence = default(ulong);
				((FastBufferReader)(ref reader)).ReadValueSafe<ulong>(ref sequence, default(ForPrimitives));
				if (num == state.Epoch)
				{
					ApplyTravel(client, entering, sequence);
				}
			}
		}

		private void ApplyTravel(ulong client, bool entering, ulong sequence)
		{
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: 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)
			if (sequence <= lastAppliedUse)
			{
				return;
			}
			lastAppliedUse = sequence;
			PlayerControllerB val = Player(client);
			if (!Object.op_Implicit((Object)(object)val))
			{
				return;
			}
			Vector3 val2 = (entering ? state.InsideFeet : state.OutsideFeet);
			float num = (entering ? state.InsideYaw : state.OutsideYaw);
			val.isInsideFactory = entering;
			val.isInElevator = false;
			val.isInHangarShipRoom = false;
			val.ResetFallGravity();
			val.TeleportPlayer(val2, true, num, false, true);
			if (val.ItemSlots != null)
			{
				GrabbableObject[] itemSlots = val.ItemSlots;
				foreach (GrabbableObject val3 in itemSlots)
				{
					if (Object.op_Implicit((Object)(object)val3))
					{
						val3.isInFactory = entering;
					}
				}
			}
			if (Object.op_Implicit((Object)(object)val.ItemOnlySlot))
			{
				val.ItemOnlySlot.isInFactory = entering;
			}
			world.PlayTravel(entering, val);
		}

		private void Awake()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Expected O, but got Unknown
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Expected O, but got Unknown
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Expected O, but got Unknown
			GameObject gameObject = ((Component)this).gameObject;
			((Object)gameObject).hideFlags = (HideFlags)(((Object)gameObject).hideFlags | 0x3D);
			Object.DontDestroyOnLoad((Object)(object)((Component)this).gameObject);
			enabledMod = ((BaseUnityPlugin)this).Config.Bind<bool>("Host", "Enabled", true, "Generate an extra hatch and return rope. Host setting.");
			chance = ((BaseUnityPlugin)this).Config.Bind<int>("Host", "SpawnChance", 100, new ConfigDescription("Chance per landing, in percent. Host setting.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 100), Array.Empty<object>()));
			holdTime = ((BaseUnityPlugin)this).Config.Bind<float>("Host", "HoldTime", 1.2f, new ConfigDescription("Seconds to hold the normal interact button. Synced by the host.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.5f, 5f), Array.Empty<object>()));
			minimumDistance = ((BaseUnityPlugin)this).Config.Bind<float>("Host", "MinimumEntranceDistance", 10f, new ConfigDescription("Minimum distance from existing entrances, in metres. Host setting.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(3f, 50f), Array.Empty<object>()));
			SceneManager.sceneUnloaded += SceneUnloaded;
			((BaseUnityPlugin)this).Logger.LogInfo((object)"Another Entrance 0.1.1 loaded. All players need this mod.");
		}

		private void Update()
		{
			if (Time.unscaledTime < nextPoll)
			{
				return;
			}
			nextPoll = Time.unscaledTime + 0.1f;
			NetworkManager singleton = NetworkManager.Singleton;
			if (!Object.op_Implicit((Object)(object)singleton) || !singleton.IsListening)
			{
				if ((Object)(object)network != (Object)null)
				{
					ResetSession();
				}
				return;
			}
			if ((Object)(object)network != (Object)(object)singleton)
			{
				ResetSession();
				network = singleton;
			}
			BindMessages();
			if (!Ready)
			{
				if (landing)
				{
					ClearLanding();
				}
				return;
			}
			if (!landing)
			{
				landing = true;
				if (network.IsServer)
				{
					placing = ((MonoBehaviour)this).StartCoroutine(PlaceEntrance());
				}
			}
			if (!network.IsServer && !stateKnown && messenger != null && Time.unscaledTime >= nextRequest)
			{
				nextRequest = Time.unscaledTime + 2f;
				RequestState();
			}
		}

		private IEnumerator PlaceEntrance()
		{
			yield return (object)new WaitForSeconds(1f);
			StartOfRound round = StartOfRound.Instance;
			state = new EntranceState
			{
				Epoch = ++nextEpoch,
				Seed = round.randomMapSeed,
				Level = round.currentLevelID,
				HoldTime = holdTime.Value
			};
			Random random = new Random(state.Seed ^ 0x4A7E913B);
			if (enabledMod.Value && random.Next(100) < chance.Value)
			{
				EntrancePlacement placement = new EntrancePlacement(random, minimumDistance.Value);
				yield return placement.Find();
				if (!Ready)
				{
					yield break;
				}
				if (placement.Found)
				{
					state.Exists = true;
					state.OutsideHatch = placement.OutsideHatch;
					state.OutsideFeet = placement.OutsideFeet;
					state.OutsideYaw = placement.OutsideYaw;
					state.InsideFeet = placement.InsideFeet;
					state.InsideYaw = placement.InsideYaw;
					state.Ceiling = placement.Ceiling;
					((BaseUnityPlugin)this).Logger.LogInfo((object)("Extra entrance placed: outside " + ((Vector3)(ref state.OutsideHatch)).ToString("F2") + ", inside " + ((Vector3)(ref state.InsideFeet)).ToString("F2") + ", ceiling " + state.Ceiling.ToString("F2")));
				}
				else
				{
					((BaseUnityPlugin)this).Logger.LogWarning((object)("No safe hatch/ceiling pair found on " + round.currentLevel.sceneName + ". Skipping this landing. " + placement.Diagnostics));
				}
			}
			stateKnown = true;
			BuildWorld();
			BroadcastState();
			placing = null;
		}

		private bool BuildWorld()
		{
			//IL_0037: 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_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			world?.Dispose();
			world = null;
			if (!state.Exists)
			{
				return true;
			}
			try
			{
				Scene scene = SceneManager.GetSceneByName(StartOfRound.Instance.currentLevel.sceneName);
				if (!((Scene)(ref scene)).IsValid() || !((Scene)(ref scene)).isLoaded)
				{
					scene = SceneManager.GetActiveScene();
				}
				world = new EntranceWorld(this, state, scene);
				return true;
			}
			catch (Exception ex)
			{
				((BaseUnityPlugin)this).Logger.LogError((object)("Failed to construct the entrance: " + ex));
				if (network.IsServer)
				{
					state.Exists = false;
				}
				return false;
			}
		}

		private void SceneUnloaded(Scene scene)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			if (world != null && world.Scene == scene)
			{
				ClearLanding();
			}
		}

		private void ClearLanding()
		{
			if (placing != null)
			{
				((MonoBehaviour)this).StopCoroutine(placing);
			}
			placing = null;
			world?.Dispose();
			world = null;
			landing = false;
			stateKnown = false;
			minimumEpoch = Math.Max(minimumEpoch, state.Epoch);
			state = default(EntranceState);
			nextRequest = 0f;
			localCooldown = 0f;
			holds.Clear();
			lastUse.Clear();
		}

		private void ResetSession()
		{
			UnbindMessages();
			ClearLanding();
			network = null;
			minimumEpoch = 0uL;
			lastAppliedUse = 0uL;
			useSequence = 0uL;
		}

		private void OnDestroy()
		{
			SceneManager.sceneUnloaded -= SceneUnloaded;
			ResetSession();
		}

		internal void Use(bool entering, byte action)
		{
			PlayerControllerB localPlayer = LocalPlayer;
			if (Object.op_Implicit((Object)(object)localPlayer) && !localPlayer.isPlayerDead && Ready && world != null && state.Exists && messenger != null && !(Time.unscaledTime < localCooldown))
			{
				if (action == 1)
				{
					localCooldown = Time.unscaledTime + 1f;
				}
				if (network.IsServer)
				{
					HandleUse(network.LocalClientId, state.Epoch, entering, action);
				}
				else
				{
					SendUse(state.Epoch, entering, action);
				}
			}
		}
	}
	internal sealed class EntrancePlacement
	{
		internal static readonly int GeometryMask = LayerMask.GetMask(new string[5] { "Default", "Room", "Colliders", "Terrain", "MiscLevelGeometry" });

		private static Collider[] overlaps = (Collider[])(object)new Collider[64];

		private readonly Random random;

		private readonly float distanceSquared;

		private readonly List<Vector3> outsideDoors = new List<Vector3>();

		private readonly List<Vector3> insideDoors = new List<Vector3>();

		private readonly Bounds shipBounds;

		private readonly bool hasShip;

		private readonly NavMeshPath path = new NavMeshPath();

		private int outdoorGround;

		private int outdoorDoors;

		private int outdoorPaths;

		private int outdoorSpace;

		private int indoorGround;

		private int indoorCeiling;

		internal bool Found;

		internal Vector3 OutsideHatch;

		internal Vector3 OutsideFeet;

		internal float OutsideYaw;

		internal Vector3 InsideFeet;

		internal float InsideYaw;

		internal float Ceiling;

		internal string Diagnostics => "Rejected: outdoor ground=" + outdoorGround + ", outdoor space=" + outdoorSpace + ", outdoor doors=" + outdoorDoors + ", outdoor paths=" + outdoorPaths + ", indoor ground=" + indoorGround + ", ceiling=" + indoorCeiling;

		internal EntrancePlacement(Random random, float distance)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Expected O, but got Unknown
			//IL_0061: 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_00a3: Unknown result type (might be due to invalid IL or missing references)
			this.random = random;
			distanceSquared = distance * distance;
			EntranceTeleport[] array = Object.FindObjectsOfType<EntranceTeleport>();
			foreach (EntranceTeleport val in array)
			{
				(val.isEntranceToBuilding ? outsideDoors : insideDoors).Add(((Component)val).transform.position);
			}
			StartOfRound instance = StartOfRound.Instance;
			if (Object.op_Implicit((Object)(object)instance) && Object.op_Implicit((Object)(object)instance.shipInnerRoomBounds))
			{
				hasShip = true;
				shipBounds = instance.shipInnerRoomBounds.bounds;
			}
		}

		internal IEnumerator Find()
		{
			Physics.SyncTransforms();
			RoundManager instance = RoundManager.Instance;
			List<Vector3> outside = Nodes(instance.outsideAINodes, "OutsideAINode");
			List<Vector3> inside = Nodes(instance.insideAINodes, "AINode");
			if (outside.Count == 0 || inside.Count == 0)
			{
				yield break;
			}
			bool haveOutside = false;
			for (int i = 0; i < 640; i++)
			{
				if (haveOutside)
				{
					break;
				}
				if (i % 12 == 0)
				{
					yield return null;
				}
				Vector3 val = outside[random.Next(outside.Count)];
				if (!Ground(Jitter(val, (i % 4 == 0) ? 0f : 9f), 3f, out var floor))
				{
					outdoorGround++;
					continue;
				}
				if (!FarFromDoors(floor, outdoors: true))
				{
					outdoorDoors++;
					continue;
				}
				if (!Connected(val, floor))
				{
					outdoorPaths++;
					continue;
				}
				float yaw = (float)random.NextDouble() * 360f;
				if (!Outside(floor, yaw))
				{
					outdoorSpace++;
				}
				else
				{
					haveOutside = true;
				}
			}
			if (!haveOutside)
			{
				yield break;
			}
			for (int i = 0; i < 640; i++)
			{
				if (i % 12 == 0)
				{
					yield return null;
				}
				Vector3 val2 = inside[random.Next(inside.Count)];
				if (!Ground(Jitter(val2, (i % 4 == 0) ? 0f : 4.5f), 2.5f, out var floor2) || !FarFromDoors(floor2, outdoors: false) || !Connected(val2, floor2) || !ClearLanding(floor2 + Vector3.up * 0.04f))
				{
					indoorGround++;
					continue;
				}
				if (!FindCeiling(floor2, out var ceiling))
				{
					indoorCeiling++;
					continue;
				}
				InsideFeet = floor2 + Vector3.up * 0.04f;
				InsideYaw = OpenDirection(floor2);
				Ceiling = ceiling;
				Found = true;
				break;
			}
		}

		private static List<Vector3> Nodes(GameObject[] cached, string tag)
		{
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			List<Vector3> list = new List<Vector3>();
			GameObject[] array = ((cached != null && cached.Length != 0) ? cached : GameObject.FindGameObjectsWithTag(tag));
			foreach (GameObject val in array)
			{
				if (Object.op_Implicit((Object)(object)val) && val.activeInHierarchy)
				{
					list.Add(val.transform.position);
				}
			}
			if (list.Count == 0 && cached != null && cached.Length != 0)
			{
				array = GameObject.FindGameObjectsWithTag(tag);
				foreach (GameObject val2 in array)
				{
					if (Object.op_Implicit((Object)(object)val2) && val2.activeInHierarchy)
					{
						list.Add(val2.transform.position);
					}
				}
			}
			return list;
		}

		private Vector3 Jitter(Vector3 position, float radius)
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: 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)
			double num = random.NextDouble() * Math.PI * 2.0;
			float num2 = Mathf.Sqrt((float)random.NextDouble()) * radius;
			return position + new Vector3((float)Math.Cos(num) * num2, 0f, (float)Math.Sin(num) * num2);
		}

		private bool FarFromDoors(Vector3 point, bool outdoors)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: 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_0067: Unknown result type (might be due to invalid IL or missing references)
			foreach (Vector3 item in outdoors ? outsideDoors : insideDoors)
			{
				Vector3 val = item - point;
				if (((Vector3)(ref val)).sqrMagnitude < distanceSquared)
				{
					return false;
				}
			}
			if (outdoors && hasShip)
			{
				Bounds val2 = shipBounds;
				if (((Bounds)(ref val2)).SqrDistance(point) < 36f)
				{
					return false;
				}
			}
			return true;
		}

		private bool Connected(Vector3 origin, Vector3 destination)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Invalid comparison between Unknown and I4
			NavMeshHit val = default(NavMeshHit);
			if (Ground(origin, 4f, out var floor) && NavMesh.SamplePosition(floor, ref val, 1f, -1) && NavMesh.CalculatePath(((NavMeshHit)(ref val)).position, destination, -1, path))
			{
				return (int)path.status == 0;
			}
			return false;
		}

		private static bool Ground(Vector3 probe, float navRadius, out Vector3 floor)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: 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_0083: 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_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			floor = default(Vector3);
			RaycastHit val = default(RaycastHit);
			NavMeshHit val2 = default(NavMeshHit);
			if (!Physics.Raycast(probe + Vector3.up * 2f, Vector3.down, ref val, 18f, GeometryMask, (QueryTriggerInteraction)1) || ((RaycastHit)(ref val)).normal.y < 0.78f || !NavMesh.SamplePosition(((RaycastHit)(ref val)).point, ref val2, navRadius, -1) || Mathf.Abs(((RaycastHit)(ref val)).point.y - ((NavMeshHit)(ref val2)).position.y) > 0.65f)
			{
				return false;
			}
			RaycastHit val3 = default(RaycastHit);
			if (!Physics.Raycast(((NavMeshHit)(ref val2)).position + Vector3.up * 0.6f, Vector3.down, ref val3, 1.3f, GeometryMask, (QueryTriggerInteraction)1) || ((RaycastHit)(ref val3)).normal.y < 0.78f)
			{
				return false;
			}
			floor = ((RaycastHit)(ref val3)).point;
			return !Dangerous(floor);
		}

		private bool Outside(Vector3 floor, float yaw)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: 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_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			//IL_011a: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0133: Unknown result type (might be due to invalid IL or missing references)
			//IL_0138: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_0169: 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_017d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0182: Unknown result type (might be due to invalid IL or missing references)
			//IL_0184: 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_0187: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_019d: Unknown result type (might be due to invalid IL or missing references)
			//IL_019f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dc: 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_01e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0204: Unknown result type (might be due to invalid IL or missing references)
			//IL_0206: Unknown result type (might be due to invalid IL or missing references)
			//IL_0210: Unknown result type (might be due to invalid IL or missing references)
			//IL_0215: Unknown result type (might be due to invalid IL or missing references)
			//IL_021a: Unknown result type (might be due to invalid IL or missing references)
			//IL_021b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0225: Unknown result type (might be due to invalid IL or missing references)
			//IL_022a: Unknown result type (might be due to invalid IL or missing references)
			//IL_023d: Unknown result type (might be due to invalid IL or missing references)
			//IL_023e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0244: Unknown result type (might be due to invalid IL or missing references)
			//IL_0246: Unknown result type (might be due to invalid IL or missing references)
			//IL_0250: Unknown result type (might be due to invalid IL or missing references)
			//IL_0255: Unknown result type (might be due to invalid IL or missing references)
			//IL_025a: Unknown result type (might be due to invalid IL or missing references)
			Quaternion val = Quaternion.Euler(0f, yaw, 0f);
			float num = floor.y;
			float num2 = floor.y;
			RaycastHit val2 = default(RaycastHit);
			for (int i = -1; i <= 1; i++)
			{
				for (int j = -1; j <= 1; j++)
				{
					if (!Physics.Raycast(floor + val * new Vector3((float)i * 0.94f, 0f, (float)j * 0.94f) + Vector3.up * 1.7f, Vector3.down, ref val2, 3.7f, GeometryMask, (QueryTriggerInteraction)1) || ((RaycastHit)(ref val2)).normal.y < 0.7f || Dangerous(((RaycastHit)(ref val2)).point))
					{
						return false;
					}
					num = Mathf.Min(num, ((RaycastHit)(ref val2)).point.y);
					num2 = Mathf.Max(num2, ((RaycastHit)(ref val2)).point.y);
				}
			}
			if (num2 - num > 0.95f)
			{
				return false;
			}
			Vector3 val3 = default(Vector3);
			((Vector3)(ref val3))..ctor(floor.x, num2 + 0.14f, floor.z);
			if (Physics.CheckBox(val3 + Vector3.up * 0.65f, new Vector3(1.01f, 0.6f, 1.01f), val, GeometryMask, (QueryTriggerInteraction)1))
			{
				return false;
			}
			for (int k = 0; k < 4; k++)
			{
				float num3 = yaw + (float)k * 90f;
				Vector3 val4 = Quaternion.Euler(0f, num3, 0f) * Vector3.forward * 1.85f;
				if (Ground(floor + val4, 0.65f, out var floor2))
				{
					Vector3 val5 = floor2 - floor - val4;
					if (!(((Vector3)(ref val5)).sqrMagnitude > 1.44f) && !(Mathf.Abs(floor2.y - floor.y) > 0.8f) && ClearLanding(floor2 + Vector3.up * 0.04f) && Connected(floor, floor2) && !Physics.Linecast(floor2 + Vector3.up * 1.2f, val3 + Vector3.up * 0.2f, GeometryMask, (QueryTriggerInteraction)1))
					{
						OutsideHatch = val3;
						OutsideFeet = floor2 + Vector3.up * 0.04f;
						OutsideYaw = num3;
						return true;
					}
				}
			}
			return false;
		}

		private static bool FindCeiling(Vector3 floor, out float ceiling)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Unknown result type (might be due to invalid IL or missing references)
			//IL_0137: Unknown result type (might be due to invalid IL or missing references)
			//IL_013d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			ceiling = 0f;
			RaycastHit val = default(RaycastHit);
			if (!Physics.Raycast(floor + Vector3.up * 1.9f, Vector3.up, ref val, 7.6f, GeometryMask, (QueryTriggerInteraction)1) || ((RaycastHit)(ref val)).normal.y > -0.9f)
			{
				return false;
			}
			ceiling = ((RaycastHit)(ref val)).point.y - 0.025f;
			if (ceiling - floor.y < 2.6f || ceiling - floor.y > 9.3f)
			{
				return false;
			}
			Vector3 val2 = default(Vector3);
			RaycastHit val3 = default(RaycastHit);
			for (int i = -1; i <= 1; i += 2)
			{
				for (int j = -1; j <= 1; j += 2)
				{
					((Vector3)(ref val2))..ctor((float)i * 1f, 1.9f, (float)j * 1f);
					if (!Physics.Raycast(floor + val2, Vector3.up, ref val3, 7.6f, GeometryMask, (QueryTriggerInteraction)1) || ((RaycastHit)(ref val3)).normal.y > -0.9f || Mathf.Abs(((RaycastHit)(ref val3)).point.y - ((RaycastHit)(ref val)).point.y) > 0.12f)
					{
						return false;
					}
				}
			}
			return !Physics.CheckCapsule(floor + Vector3.up * 0.75f, new Vector3(floor.x, ceiling - 0.25f, floor.z), 0.16f, GeometryMask, (QueryTriggerInteraction)1);
		}

		private float OpenDirection(Vector3 floor)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: 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_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			float result = 0f;
			float num = -1f;
			RaycastHit val2 = default(RaycastHit);
			for (int i = 0; i < 12; i++)
			{
				float num2 = (float)i * 30f;
				Vector3 val = Quaternion.Euler(0f, num2, 0f) * Vector3.forward;
				float num3 = (Physics.Raycast(floor + Vector3.up, val, ref val2, 8f, GeometryMask, (QueryTriggerInteraction)1) ? ((RaycastHit)(ref val2)).distance : 8f);
				if (num3 > num)
				{
					result = num2;
					num = num3;
				}
			}
			return result;
		}

		internal static bool ClearLanding(Vector3 feet)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: 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_0047: 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_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: 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)
			if (Physics.CheckCapsule(feet + Vector3.up * 0.48f, feet + Vector3.up * 1.65f, 0.4f, GeometryMask, (QueryTriggerInteraction)1) || Dangerous(feet))
			{
				return false;
			}
			RaycastHit val = default(RaycastHit);
			if (Physics.Raycast(feet + Vector3.up * 0.1f, Vector3.down, ref val, 0.4f, GeometryMask, (QueryTriggerInteraction)1))
			{
				return ((RaycastHit)(ref val)).normal.y >= 0.78f;
			}
			return false;
		}

		private static bool Dangerous(Vector3 feet)
		{
			//IL_0015: 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_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			int num;
			while ((num = Physics.OverlapCapsuleNonAlloc(feet + Vector3.up * 0.3f, feet + Vector3.up * 1.5f, 0.55f, overlaps, -1, (QueryTriggerInteraction)2)) == overlaps.Length)
			{
				Array.Resize(ref overlaps, checked(overlaps.Length * 2));
			}
			bool result = false;
			for (int i = 0; i < num; i++)
			{
				if (Object.op_Implicit((Object)(object)overlaps[i]) && (Object.op_Implicit((Object)(object)((Component)overlaps[i]).GetComponentInParent<QuicksandTrigger>()) || Object.op_Implicit((Object)(object)((Component)overlaps[i]).GetComponentInParent<KillLocalPlayer>())))
				{
					result = true;
					break;
				}
			}
			Array.Clear(overlaps, 0, overlaps.Length);
			return result;
		}
	}
	internal struct EntranceState
	{
		internal const int Size = 69;

		internal ulong Epoch;

		internal int Seed;

		internal int Level;

		internal bool Exists;

		internal Vector3 OutsideHatch;

		internal Vector3 OutsideFeet;

		internal float OutsideYaw;

		internal Vector3 InsideFeet;

		internal float InsideYaw;

		internal float Ceiling;

		internal float HoldTime;

		internal bool Valid
		{
			get
			{
				//IL_000c: Unknown result type (might be due to invalid IL or missing references)
				//IL_001c: Unknown result type (might be due to invalid IL or missing references)
				//IL_002c: Unknown result type (might be due to invalid IL or missing references)
				//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
				//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
				if (Epoch != 0L && Finite(OutsideHatch) && Finite(OutsideFeet) && Finite(InsideFeet) && Finite(OutsideYaw) && Finite(InsideYaw) && Finite(Ceiling) && Finite(HoldTime) && HoldTime >= 0.5f && HoldTime <= 5f)
				{
					if (Exists)
					{
						if (Ceiling - InsideFeet.y >= 2.5f && Ceiling - InsideFeet.y <= 10f)
						{
							Vector3 val = OutsideHatch - OutsideFeet;
							return ((Vector3)(ref val)).sqrMagnitude < 25f;
						}
						return false;
					}
					return true;
				}
				return false;
			}
		}

		internal void Write(FastBufferWriter writer)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: 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_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: 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_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			((FastBufferWriter)(ref writer)).WriteValueSafe<ulong>(ref Epoch, default(ForPrimitives));
			((FastBufferWriter)(ref writer)).WriteValueSafe<int>(ref Seed, default(ForPrimitives));
			((FastBufferWriter)(ref writer)).WriteValueSafe<int>(ref Level, default(ForPrimitives));
			((FastBufferWriter)(ref writer)).WriteValueSafe<bool>(ref Exists, default(ForPrimitives));
			((FastBufferWriter)(ref writer)).WriteValueSafe(ref OutsideHatch);
			((FastBufferWriter)(ref writer)).WriteValueSafe(ref OutsideFeet);
			((FastBufferWriter)(ref writer)).WriteValueSafe<float>(ref OutsideYaw, default(ForPrimitives));
			((FastBufferWriter)(ref writer)).WriteValueSafe(ref InsideFeet);
			((FastBufferWriter)(ref writer)).WriteValueSafe<float>(ref InsideYaw, default(ForPrimitives));
			((FastBufferWriter)(ref writer)).WriteValueSafe<float>(ref Ceiling, default(ForPrimitives));
			((FastBufferWriter)(ref writer)).WriteValueSafe<float>(ref HoldTime, default(ForPrimitives));
		}

		internal static EntranceState Read(FastBufferReader reader)
		{
			//IL_0013: 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)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//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)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			EntranceState result = default(EntranceState);
			((FastBufferReader)(ref reader)).ReadValueSafe<ulong>(ref result.Epoch, default(ForPrimitives));
			((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref result.Seed, default(ForPrimitives));
			((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref result.Level, default(ForPrimitives));
			((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref result.Exists, default(ForPrimitives));
			((FastBufferReader)(ref reader)).ReadValueSafe(ref result.OutsideHatch);
			((FastBufferReader)(ref reader)).ReadValueSafe(ref result.OutsideFeet);
			((FastBufferReader)(ref reader)).ReadValueSafe<float>(ref result.OutsideYaw, default(ForPrimitives));
			((FastBufferReader)(ref reader)).ReadValueSafe(ref result.InsideFeet);
			((FastBufferReader)(ref reader)).ReadValueSafe<float>(ref result.InsideYaw, default(ForPrimitives));
			((FastBufferReader)(ref reader)).ReadValueSafe<float>(ref result.Ceiling, default(ForPrimitives));
			((FastBufferReader)(ref reader)).ReadValueSafe<float>(ref result.HoldTime, default(ForPrimitives));
			return result;
		}

		private static bool Finite(Vector3 value)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			if (Finite(value.x) && Finite(value.y))
			{
				return Finite(value.z);
			}
			return false;
		}

		private static bool Finite(float value)
		{
			if (!float.IsNaN(value))
			{
				return !float.IsInfinity(value);
			}
			return false;
		}
	}
	internal sealed class EntranceWorld : IDisposable
	{
		private static readonly Dictionary<PrimitiveType, Mesh> primitiveMeshes = new Dictionary<PrimitiveType, Mesh>();

		private readonly EntrancePlugin plugin;

		private readonly GameObject root;

		private readonly Shader shader;

		private readonly List<Object> resources = new List<Object>();

		private readonly Material concrete;

		private readonly Material metal;

		private readonly Material dark;

		private readonly Material rust;

		private readonly Material yellow;

		private readonly Material rope;

		private readonly Material ropeLight;

		private readonly AudioSource outsideAudio;

		private readonly AudioSource insideAudio;

		private readonly EntranceTeleport entranceAudioTemplate;

		private readonly EntranceTeleport exitAudioTemplate;

		private readonly AudioReverbPresets reverbPresets;

		internal Scene Scene { get; private set; }

		internal EntranceWorld(EntrancePlugin plugin, EntranceState state, Scene scene)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Expected O, but got Unknown
			//IL_0035: 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_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			//IL_0143: Unknown result type (might be due to invalid IL or missing references)
			//IL_0172: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_020a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0223: Unknown result type (might be due to invalid IL or missing references)
			//IL_0234: Unknown result type (might be due to invalid IL or missing references)
			//IL_023e: Unknown result type (might be due to invalid IL or missing references)
			//IL_025d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0296: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ac: Unknown result type (might be due to invalid IL or missing references)
			this.plugin = plugin;
			Scene = scene;
			root = new GameObject("AnotherEntrance");
			SceneManager.MoveGameObjectToScene(root, scene);
			try
			{
				shader = Shader.Find("HDRP/Lit") ?? Shader.Find("Standard");
				if (!Object.op_Implicit((Object)(object)shader))
				{
					throw new InvalidOperationException("No supported opaque material shader found.");
				}
				concrete = Material("Aged concrete", new Color(0.38f, 0.39f, 0.36f), 0f, 0.12f);
				metal = Material("Oxidised hatch steel", new Color(0.22f, 0.29f, 0.27f), 0.7f, 0.25f);
				dark = Material("Dark recesses", new Color(0.048f, 0.055f, 0.05f), 0.35f, 0.18f);
				rust = Material("Rusty hardware", new Color(0.27f, 0.13f, 0.065f), 0.55f, 0.2f);
				yellow = Material("Faded safety yellow", new Color(0.65f, 0.48f, 0.14f), 0.2f, 0.15f);
				rope = Material("Hemp rope", new Color(0.35f, 0.26f, 0.14f), 0f, 0.08f);
				ropeLight = Material("Hemp strands", new Color(0.51f, 0.41f, 0.25f), 0f, 0.08f);
				AddConcreteTexture();
				Transform val = Anchor("Surface hatch and buried concrete shaft", state.OutsideHatch, state.OutsideYaw);
				BuildHatch(val, ceiling: false);
				InteractTrigger val2 = Interaction(val, "Hatch interaction", new Vector3(0f, 0.15f, 0f), new Vector3(1.46f, 0.2f, 1.46f), entering: true, state.HoldTime);
				Transform val3 = Anchor("Ceiling hatch and return rope", new Vector3(state.InsideFeet.x, state.Ceiling, state.InsideFeet.z), 0f);
				BuildHatch(val3, ceiling: true);
				float num = state.Ceiling - state.InsideFeet.y - 0.85f;
				BuildRope(val3, num);
				InteractTrigger val4 = Interaction(val3, "Rope interaction", new Vector3(0f, (0f - num) * 0.5f - 0.05f, 0f), new Vector3(0.3f, num + 0.28f, 0.3f), entering: false, state.HoldTime);
				CombineVisuals(val);
				CombineVisuals(val3);
				outsideAudio = Audio(val);
				insideAudio = Audio(val3);
				EntranceTeleport[] array = Object.FindObjectsOfType<EntranceTeleport>();
				foreach (EntranceTeleport val5 in array)
				{
					if (val5.isEntranceToBuilding && !Object.op_Implicit((Object)(object)entranceAudioTemplate))
					{
						entranceAudioTemplate = val5;
					}
					if (!val5.isEntranceToBuilding && !Object.op_Implicit((Object)(object)exitAudioTemplate))
					{
						exitAudioTemplate = val5;
					}
				}
				InteractTrigger val6 = (Object.op_Implicit((Object)(object)entranceAudioTemplate) ? ((Component)entranceAudioTemplate).GetComponent<InteractTrigger>() : null);
				if (Object.op_Implicit((Object)(object)val6))
				{
					val2.hoverIcon = (val4.hoverIcon = val6.hoverIcon);
					val2.disabledHoverIcon = (val4.disabledHoverIcon = val6.disabledHoverIcon);
				}
				reverbPresets = Object.FindObjectOfType<AudioReverbPresets>();
				Physics.SyncTransforms();
			}
			catch
			{
				Dispose();
				throw;
			}
		}

		private Transform Anchor(string name, Vector3 position, float yaw)
		{
			//IL_0001: 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_002a: Unknown result type (might be due to invalid IL or missing references)
			Transform transform = new GameObject(name).transform;
			transform.SetParent(root.transform, false);
			transform.SetPositionAndRotation(position, Quaternion.Euler(0f, yaw, 0f));
			return transform;
		}

		private void BuildHatch(Transform anchor, bool ceiling)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: 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)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			//IL_0134: Unknown result type (might be due to invalid IL or missing references)
			//IL_0169: Unknown result type (might be due to invalid IL or missing references)
			//IL_017d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0239: Unknown result type (might be due to invalid IL or missing references)
			//IL_024d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0278: Unknown result type (might be due to invalid IL or missing references)
			//IL_028c: Unknown result type (might be due to invalid IL or missing references)
			//IL_035e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0372: Unknown result type (might be due to invalid IL or missing references)
			//IL_0399: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0307: Unknown result type (might be due to invalid IL or missing references)
			//IL_031b: Unknown result type (might be due to invalid IL or missing references)
			Transform transform = new GameObject("Concrete collar and steel cover").transform;
			transform.SetParent(anchor, false);
			if (ceiling)
			{
				transform.localRotation = Quaternion.Euler(180f, 0f, 0f);
			}
			float num = (ceiling ? 0.22f : 2.6f);
			for (int i = -1; i <= 1; i += 2)
			{
				Box(transform, "Concrete shaft wall", new Vector3((float)i * 0.84f, (0f - num) * 0.5f, 0f), new Vector3(0.3f, num, 1.98f), concrete, solid: false);
				Box(transform, "Concrete shaft wall", new Vector3(0f, (0f - num) * 0.5f, (float)i * 0.84f), new Vector3(1.38f, num, 0.3f), concrete, solid: false);
				Box(transform, "Concrete lip", new Vector3((float)i * 0.85f, 0.01f, 0f), new Vector3(0.3f, 0.16f, 1.98f), concrete, !ceiling);
				Box(transform, "Concrete lip", new Vector3(0f, 0.01f, (float)i * 0.85f), new Vector3(1.4f, 0.16f, 0.3f), concrete, !ceiling);
			}
			Box(transform, "Steel rim shadow", new Vector3(0f, 0.035f, 0f), new Vector3(1.49f, 0.055f, 1.49f), dark, solid: false);
			Box(transform, "Closed steel hatch", new Vector3(0f, 0.075f, 0f), new Vector3(1.35f, 0.06f, 1.35f), metal, !ceiling);
			for (int j = -2; j <= 2; j++)
			{
				Box(transform, "Pressed steel rib", new Vector3((float)j * 0.22f, 0.112f, 0f), new Vector3(0.038f, 0.025f, 1.13f), metal, solid: false);
			}
			for (int k = -1; k <= 1; k += 2)
			{
				Box(transform, "Hatch hinge", new Vector3((float)k * 0.43f, 0.13f, -0.66f), new Vector3(0.23f, 0.1f, 0.14f), rust, solid: false);
				Box(transform, "Handle foot", new Vector3((float)k * 0.15f, 0.16f, 0.37f), new Vector3(0.045f, 0.12f, 0.045f), rust, solid: false);
				for (int l = -1; l <= 1; l += 2)
				{
					Primitive(transform, (PrimitiveType)2, "Anchor bolt", new Vector3((float)k * 0.85f, 0.108f, (float)l * 0.69f), new Vector3(0.07f, 0.025f, 0.07f), dark);
					Box(transform, "Worn warning stripe", new Vector3((float)k * 0.82f, 0.097f, (float)l * 0.29f), new Vector3(0.18f, 0.008f, 0.38f), yellow, solid: false);
				}
			}
			Box(transform, "Hatch pull handle", new Vector3(0f, 0.22f, 0.37f), new Vector3(0.34f, 0.045f, 0.045f), rust, solid: false);
			Box(transform, "Maintenance plate", new Vector3(0.36f, 0.13f, 0.32f), new Vector3(0.22f, 0.012f, 0.32f), dark, solid: false);
		}

		private void BuildRope(Transform anchor, float length)
		{
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: 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_0164: Unknown result type (might be due to invalid IL or missing references)
			//IL_0169: Unknown result type (might be due to invalid IL or missing references)
			//IL_01aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_01be: Unknown result type (might be due to invalid IL or missing references)
			int num = Mathf.CeilToInt(length * 42f);
			for (int i = 0; i < 3; i++)
			{
				Vector3[] array = (Vector3[])(object)new Vector3[num + 1];
				for (int j = 0; j <= num; j++)
				{
					float num2 = (float)j / (float)num;
					float num3 = (float)i * (float)Math.PI * 2f / 3f + num2 * length * 34f;
					array[j] = new Vector3(Mathf.Cos(num3) * 0.022f, -0.17f - num2 * (length - 0.17f), Mathf.Sin(num3) * 0.022f);
				}
				Tube(anchor, "Twisted rope strand", array, 0.017f, (i == 1) ? ropeLight : rope);
			}
			for (float num4 = 0.45f; num4 < length - 0.15f; num4 += 0.65f)
			{
				Primitive(anchor, (PrimitiveType)0, "Rope grip knot", new Vector3(0f, 0f - num4, 0f), new Vector3(0.105f, 0.13f, 0.09f), rope);
			}
			Vector3[] array2 = (Vector3[])(object)new Vector3[33];
			for (int k = 0; k < array2.Length; k++)
			{
				float num5 = (float)k * (float)Math.PI * 2f / (float)(array2.Length - 1);
				array2[k] = new Vector3(Mathf.Sin(num5) * 0.11f, 0f - length - 0.11f + Mathf.Cos(num5) * 0.14f, 0f);
			}
			Tube(anchor, "Tied bottom loop", array2, 0.033f, ropeLight);
			Primitive(anchor, (PrimitiveType)0, "Top rope knot", new Vector3(0f, -0.19f, 0f), new Vector3(0.12f, 0.14f, 0.1f), rope);
		}

		private InteractTrigger Interaction(Transform parent, string name, Vector3 point, Vector3 size, bool entering, float holdTime)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: 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_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Expected O, but got Unknown
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Expected O, but got Unknown
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Expected O, but got Unknown
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Expected O, but got Unknown
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Expected O, but got Unknown
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Expected O, but got Unknown
			GameObject val = new GameObject(name)
			{
				layer = LayerMask.NameToLayer("InteractableObject"),
				tag = "InteractTrigger"
			};
			val.transform.SetParent(parent, false);
			val.transform.localPosition = point;
			BoxCollider obj = val.AddComponent<BoxCollider>();
			obj.size = size;
			((Collider)obj).isTrigger = true;
			InteractTrigger obj2 = val.AddComponent<InteractTrigger>();
			obj2.interactable = true;
			obj2.interactCooldown = false;
			obj2.oneHandedItemAllowed = (obj2.twoHandedItemAllowed = true);
			obj2.holdInteraction = true;
			obj2.timeToHold = holdTime;
			obj2.hoverTip = (entering ? "Enter tunnel : [E]" : "Climb rope : [E]");
			obj2.holdTip = (entering ? "Entering..." : "Climbing...");
			obj2.disabledHoverTip = "Passage unavailable";
			obj2.onInteract = new InteractEvent();
			obj2.onInteractEarly = new InteractEvent();
			obj2.onInteractEarlyOtherClients = new InteractEvent();
			obj2.onStopInteract = new InteractEvent();
			obj2.onCancelAnimation = new InteractEvent();
			obj2.holdingInteractEvent = new InteractEventFloat();
			((UnityEvent<PlayerControllerB>)(object)obj2.onInteractEarly).AddListener((UnityAction<PlayerControllerB>)delegate
			{
				plugin.Use(entering, 0);
			});
			((UnityEvent<PlayerControllerB>)(object)obj2.onStopInteract).AddListener((UnityAction<PlayerControllerB>)delegate
			{
				plugin.Use(entering, 2);
			});
			((UnityEvent<PlayerControllerB>)(object)obj2.onInteract).AddListener((UnityAction<PlayerControllerB>)delegate(PlayerControllerB player)
			{
				if ((Object)(object)player == (Object)(object)EntrancePlugin.LocalPlayer)
				{
					plugin.Use(entering, 1);
				}
			});
			return obj2;
		}

		internal void PlayTravel(bool entering, PlayerControllerB player)
		{
			EntranceTeleport val = (entering ? entranceAudioTemplate : exitAudioTemplate);
			if (((Object)(object)player == (Object)(object)EntrancePlugin.LocalPlayer || (Object.op_Implicit((Object)(object)EntrancePlugin.LocalPlayer) && EntrancePlugin.LocalPlayer.isPlayerDead && (Object)(object)EntrancePlugin.LocalPlayer.spectatedPlayerScript == (Object)(object)player)) && Object.op_Implicit((Object)(object)val) && val.audioReverbPreset >= 0 && Object.op_Implicit((Object)(object)reverbPresets) && val.audioReverbPreset < reverbPresets.audioPresets.Length && Object.op_Implicit((Object)(object)reverbPresets.audioPresets[val.audioReverbPreset]))
			{
				reverbPresets.audioPresets[val.audioReverbPreset].ChangeAudioReverbForPlayer(player);
			}
			AudioClip[] array = ((Object.op_Implicit((Object)(object)val) && val.doorAudios != null && val.doorAudios.Length != 0) ? val.doorAudios : StartOfRound.Instance.shutDoorMetal);
			if (array != null && array.Length != 0)
			{
				AudioClip val2 = array[0];
				if (Object.op_Implicit((Object)(object)val2))
				{
					outsideAudio.PlayOneShot(val2, 0.65f);
					insideAudio.PlayOneShot(val2, 0.65f);
				}
			}
		}

		private AudioSource Audio(Transform parent)
		{
			AudioSource obj = ((Component)parent).gameObject.AddComponent<AudioSource>();
			obj.playOnAwake = false;
			obj.spatialBlend = 1f;
			obj.minDistance = 2f;
			obj.maxDistance = 18f;
			obj.rolloffMode = (AudioRolloffMode)1;
			return obj;
		}

		private Material Material(string name, Color color, float metallic, float smoothness)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Expected O, but got Unknown
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			Material val = new Material(shader)
			{
				name = "AnotherEntrance / " + name
			};
			resources.Add((Object)(object)val);
			val.SetColor((((Object)shader).name == "HDRP/Lit") ? "_BaseColor" : "_Color", color);
			val.SetFloat("_Metallic", metallic);
			val.SetFloat((((Object)shader).name == "HDRP/Lit") ? "_Smoothness" : "_Glossiness", smoothness);
			return val;
		}

		private void AddConcreteTexture()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: 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_001e: Expected O, but got Unknown
			//IL_007c: 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_00e4: Unknown result type (might be due to invalid IL or missing references)
			Texture2D val = new Texture2D(64, 64, (TextureFormat)4, true)
			{
				name = "Concrete aggregate",
				wrapMode = (TextureWrapMode)0
			};
			resources.Add((Object)(object)val);
			Color[] array = (Color[])(object)new Color[4096];
			Random random = new Random(7182);
			for (int i = 0; i < array.Length; i++)
			{
				float num = 0.68f + (float)random.NextDouble() * 0.32f;
				if (random.Next(45) == 0)
				{
					num *= 0.55f;
				}
				array[i] = new Color(num, num, num, 1f);
			}
			val.SetPixels(array);
			val.Apply(true, true);
			string text = ((((Object)shader).name == "HDRP/Lit") ? "_BaseColorMap" : "_MainTex");
			concrete.SetTexture(text, (Texture)(object)val);
			concrete.SetTextureScale(text, new Vector2(3f, 3f));
		}

		private GameObject Primitive(Transform parent, PrimitiveType type, string name, Vector3 position, Vector3 scale, Material material)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: 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_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: 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_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: 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_0092: 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_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Expected O, but got Unknown
			GameObject val = new GameObject(name, new Type[2]
			{
				typeof(MeshFilter),
				typeof(MeshRenderer)
			})
			{
				layer = LayerMask.NameToLayer("Room")
			};
			val.transform.SetParent(parent, false);
			val.transform.localPosition = position;
			val.transform.localScale = scale;
			if (!primitiveMeshes.TryGetValue(type, out var value) || !Object.op_Implicit((Object)(object)value))
			{
				GameObject obj = GameObject.CreatePrimitive(type);
				obj.SetActive(false);
				value = obj.GetComponent<MeshFilter>().sharedMesh;
				primitiveMeshes[type] = value;
				Object.Destroy((Object)(object)obj);
			}
			val.GetComponent<MeshFilter>().sharedMesh = value;
			Renderer component = val.GetComponent<Renderer>();
			component.sharedMaterial = material;
			component.shadowCastingMode = (ShadowCastingMode)1;
			return val;
		}

		private void CombineVisuals(Transform anchor)
		{
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: 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_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Expected O, but got Unknown
			//IL_0113: Unknown result type (might be due to invalid IL or missing references)
			//IL_0118: Unknown result type (might be due to invalid IL or missing references)
			//IL_0128: Unknown result type (might be due to invalid IL or missing references)
			//IL_0135: Unknown result type (might be due to invalid IL or missing references)
			MeshFilter[] componentsInChildren = ((Component)anchor).GetComponentsInChildren<MeshFilter>();
			Dictionary<Material, List<CombineInstance>> dictionary = new Dictionary<Material, List<CombineInstance>>();
			MeshFilter[] array = componentsInChildren;
			foreach (MeshFilter val in array)
			{
				Material sharedMaterial = ((Renderer)((Component)val).GetComponent<MeshRenderer>()).sharedMaterial;
				if (!dictionary.TryGetValue(sharedMaterial, out var value))
				{
					dictionary.Add(sharedMaterial, value = new List<CombineInstance>());
				}
				List<CombineInstance> list = value;
				CombineInstance item = default(CombineInstance);
				((CombineInstance)(ref item)).mesh = val.sharedMesh;
				((CombineInstance)(ref item)).transform = anchor.worldToLocalMatrix * ((Component)val).transform.localToWorldMatrix;
				list.Add(item);
			}
			foreach (KeyValuePair<Material, List<CombineInstance>> item2 in dictionary)
			{
				Mesh val2 = new Mesh
				{
					name = ((Object)item2.Key).name + " geometry"
				};
				resources.Add((Object)(object)val2);
				val2.CombineMeshes(item2.Value.ToArray(), true, true);
				val2.UploadMeshData(true);
				GameObject val3 = new GameObject(((Object)val2).name, new Type[2]
				{
					typeof(MeshFilter),
					typeof(MeshRenderer)
				})
				{
					layer = LayerMask.NameToLayer("Room")
				};
				val3.transform.SetParent(anchor, false);
				val3.GetComponent<MeshFilter>().sharedMesh = val2;
				((Renderer)val3.GetComponent<MeshRenderer>()).sharedMaterial = item2.Key;
			}
			array = componentsInChildren;
			foreach (MeshFilter val4 in array)
			{
				Mesh sharedMesh = val4.sharedMesh;
				if (resources.Remove((Object)(object)sharedMesh))
				{
					Object.Destroy((Object)(object)sharedMesh);
				}
				MeshRenderer component = ((Component)val4).GetComponent<MeshRenderer>();
				((Renderer)component).enabled = false;
				if (Object.op_Implicit((Object)(object)((Component)val4).GetComponent<Collider>()))
				{
					Object.Destroy((Object)(object)val4);
					Object.Destroy((Object)(object)component);
				}
				else
				{
					Object.Destroy((Object)(object)((Component)val4).gameObject);
				}
			}
		}

		private void Box(Transform parent, string name, Vector3 position, Vector3 size, Material material, bool solid)
		{
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = Primitive(parent, (PrimitiveType)3, name, position, size, material);
			if (solid)
			{
				val.AddComponent<BoxCollider>();
			}
		}

		private void Tube(Transform parent, string name, Vector3[] points, float radius, Material material)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: 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_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0139: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0145: Unknown result type (might be due to invalid IL or missing references)
			//IL_014c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0154: Expected O, but got Unknown
			//IL_018d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0192: Unknown result type (might be due to invalid IL or missing references)
			//IL_019f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: 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_009a: 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_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			Vector3[] array = (Vector3[])(object)new Vector3[points.Length * 6];
			int[] array2 = new int[(points.Length - 1) * 6 * 6];
			for (int i = 0; i < points.Length; i++)
			{
				Vector3 val = points[Mathf.Min(i + 1, points.Length - 1)] - points[Mathf.Max(i - 1, 0)];
				Quaternion val2 = Quaternion.LookRotation(((Vector3)(ref val)).normalized);
				for (int j = 0; j < 6; j++)
				{
					float num = (float)j * (float)Math.PI * 2f / 6f;
					array[i * 6 + j] = points[i] + val2 * new Vector3(Mathf.Cos(num), Mathf.Sin(num), 0f) * radius;
					if (i != 0)
					{
						int num2 = (i - 1) * 6 + j;
						int num3 = (i - 1) * 6 + (j + 1) % 6;
						int num4 = i * 6 + j;
						int num5 = i * 6 + (j + 1) % 6;
						int num6 = ((i - 1) * 6 + j) * 6;
						array2[num6] = num2;
						array2[num6 + 1] = num3;
						array2[num6 + 2] = num4;
						array2[num6 + 3] = num3;
						array2[num6 + 4] = num5;
						array2[num6 + 5] = num4;
					}
				}
			}
			Mesh val3 = new Mesh
			{
				name = name,
				vertices = array,
				triangles = array2
			};
			val3.RecalculateNormals();
			val3.RecalculateBounds();
			resources.Add((Object)(object)val3);
			GameObject val4 = new GameObject(name, new Type[2]
			{
				typeof(MeshFilter),
				typeof(MeshRenderer)
			});
			val4.transform.SetParent(parent, false);
			val4.GetComponent<MeshFilter>().sharedMesh = val3;
			((Renderer)val4.GetComponent<MeshRenderer>()).sharedMaterial = material;
		}

		public void Dispose()
		{
			if (Object.op_Implicit((Object)(object)root))
			{
				root.SetActive(false);
				Object.Destroy((Object)(object)root);
			}
			foreach (Object resource in resources)
			{
				if (Object.op_Implicit(resource))
				{
					Object.Destroy(resource);
				}
			}
			resources.Clear();
		}
	}
}