using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Configuration;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Photon.Pun;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: IgnoresAccessChecksTo("")]
[assembly: AssemblyCompany("EMPRESS")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.3.0.0")]
[assembly: AssemblyInformationalVersion("1.3.0+749705fb7dd252339a4fb28ec075f9ea2e513f47")]
[assembly: AssemblyProduct("Pocket Dimension Cart")]
[assembly: AssemblyTitle("PocketDimensionCart")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.3.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

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

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

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

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace Empress.PocketDimensionCart
{
	[HarmonyPatch(typeof(LevelGenerator), "Awake")]
	internal static class LevelGeneratorAwakePatch
	{
		private static void Prefix()
		{
			PocketDimensionCartRuntime.ResetLevelState();
		}
	}
	[HarmonyPatch(typeof(PhysGrabCart), "ObjectsInCart")]
	internal static class PhysGrabCartObjectsInCartPatch
	{
		private static void Prefix(PhysGrabCart __instance, out bool __state)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			__state = false;
			if (Object.op_Implicit((Object)(object)__instance) && PocketDimensionCartRuntime.IsRealLevel && !(SemiFunc.PlayerNearestDistance(((Component)__instance).transform.position) > 12f) && !(__instance.objectInCartCheckTimer > 0f))
			{
				__state = true;
			}
		}

		private static void Postfix(PhysGrabCart __instance, bool __state)
		{
			if (__state && Object.op_Implicit((Object)(object)__instance))
			{
				PocketDimensionCartController component = ((Component)__instance).GetComponent<PocketDimensionCartController>();
				if (Object.op_Implicit((Object)(object)component))
				{
					component.AddStoredContentsToCartReadout();
				}
			}
		}
	}
	[HarmonyPatch(typeof(PhysGrabCart), "Start")]
	internal static class PhysGrabCartStartPatch
	{
		private static void Postfix(PhysGrabCart __instance)
		{
			if (Object.op_Implicit((Object)(object)__instance) && PocketDimensionCartRuntime.CanAttachToCart && !Object.op_Implicit((Object)(object)((Component)__instance).GetComponent<PocketDimensionCartController>()))
			{
				((Component)__instance).gameObject.AddComponent<PocketDimensionCartController>();
			}
		}
	}
	[HarmonyPatch(typeof(PhysGrabObjectImpactDetector), "OnTriggerStay")]
	internal static class PhysGrabObjectImpactDetectorOnTriggerStayPatch
	{
		private static void Postfix(PhysGrabObjectImpactDetector __instance, Collider other)
		{
			if (Object.op_Implicit((Object)(object)__instance) && Object.op_Implicit((Object)(object)other) && PocketDimensionCartRuntime.IsRealLevel && SemiFunc.IsMasterClientOrSingleplayer() && ((Component)other).CompareTag("Cart") && __instance.isValuable && Object.op_Implicit((Object)(object)__instance.physGrabObject) && Object.op_Implicit((Object)(object)__instance.currentCart))
			{
				PocketDimensionCartController component = ((Component)__instance.currentCart).GetComponent<PocketDimensionCartController>();
				if (Object.op_Implicit((Object)(object)component))
				{
					component.StoreValuable(__instance.physGrabObject);
				}
			}
		}
	}
	[HarmonyPatch(typeof(PhysGrabCart), "StateSwitchRPC")]
	internal static class PocketDimensionCartStateSwitchGuardPatch
	{
		private static bool Prefix(PhysGrabCart __instance, State _state)
		{
			//IL_004a: 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_0052: Unknown result type (might be due to invalid IL or missing references)
			if (!Object.op_Implicit((Object)(object)__instance))
			{
				return false;
			}
			if (Object.op_Implicit((Object)(object)__instance.cartMesh) && __instance.grabMaterial != null && __instance.capsuleColliders != null && __instance.cartInside != null && __instance.soundLocked != null && __instance.soundDragged != null && __instance.soundHandled != null)
			{
				return true;
			}
			__instance.currentState = _state;
			__instance.previousState = _state;
			return false;
		}
	}
	[HarmonyPatch(typeof(PlayerController), "FixedUpdate")]
	internal static class PocketDimensionPlayerControllerFixedUpdatePatch
	{
		private static void Postfix(PlayerController __instance)
		{
			PlayerAvatar controllerPlayer = PocketDimensionCartAccess.GetControllerPlayer(__instance);
			if (PocketDimensionCartRuntime.PlayerInsideAnyPocketRoom(controllerPlayer))
			{
				PocketDimensionCartAccess.SuppressPocketRoomMovement(__instance, controllerPlayer);
			}
		}
	}
	[HarmonyPatch(typeof(PlayerTumble), "TumbleRequest")]
	internal static class PocketDimensionTumbleRequestPatch
	{
		private static bool Prefix(PlayerTumble __instance, bool _isTumbling)
		{
			if (_isTumbling)
			{
				return !BlockPocketRoomTumble(__instance);
			}
			return true;
		}

		internal static bool BlockPocketRoomTumble(PlayerTumble tumble)
		{
			PlayerAvatar tumbleOwner = PocketDimensionCartAccess.GetTumbleOwner(tumble);
			if (!PocketDimensionCartRuntime.PlayerInsideAnyPocketRoom(tumbleOwner))
			{
				return false;
			}
			PocketDimensionCartAccess.SuppressPocketRoomMovement(PlayerController.instance, tumbleOwner);
			return true;
		}
	}
	[HarmonyPatch(typeof(PlayerTumble), "TumbleRequestRPC")]
	internal static class PocketDimensionTumbleRequestRpcPatch
	{
		private static bool Prefix(PlayerTumble __instance, bool _isTumbling)
		{
			if (_isTumbling)
			{
				return !PocketDimensionTumbleRequestPatch.BlockPocketRoomTumble(__instance);
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(ValueScreen), "UpdateValue")]
	internal static class ValueScreenUpdateValuePatch
	{
		private static void Prefix(ValueScreen __instance, ref int newValue)
		{
			if (Object.op_Implicit((Object)(object)__instance) && PocketDimensionCartRuntime.IsRealLevel)
			{
				PocketDimensionCartController controllerForValueScreen = PocketDimensionCartRuntime.GetControllerForValueScreen(__instance);
				if ((Object)(object)controllerForValueScreen != (Object)null)
				{
					newValue = controllerForValueScreen.AddStoredValueToDisplay(newValue);
				}
			}
		}
	}
	internal sealed class PocketDimensionCartController : MonoBehaviourPun
	{
		private const string RequestEjectOneRpc = "PocketDimensionRequestEjectOne";

		private const string RequestEjectAllRpc = "PocketDimensionRequestEjectAll";

		private const string RequestEnterRpc = "PocketDimensionRequestEnter";

		private const string RequestLeaveRpc = "PocketDimensionRequestLeave";

		private const string StabilizeExitRpc = "PocketDimensionStabilizeExit";

		private const string SyncStoredTotalsRpc = "PocketDimensionSyncStoredTotals";

		private readonly List<int> _storedViewIds = new List<int>();

		private PhysGrabCart _cart;

		private PhotonView _cartPhotonView;

		private GameObject _roomRoot;

		private Vector3 _roomOrigin;

		private Vector3 _playerSpawnPosition;

		private Vector3 _playerExitPosition;

		private Vector3 _valuableExitPosition;

		private Collider _exitCollider;

		private float _keyDownTime;

		private float _nextLocalEnterTime;

		private float _nextLocalExitTime;

		private float _exitTouchTimer;

		private float _insideCartTimer;

		private float _nextSafePoseRefreshTime;

		private Vector3 _lastSafeCartExitPosition;

		private Quaternion _lastSafeCartExitRotation = Quaternion.identity;

		private bool _lastSafeCartExitValid;

		private bool _holdRequestSent;

		private bool _ejectAllRunning;

		private int _roomIndex;

		private int _syncedStoredCount;

		private int _syncedStoredValue;

		public int StoredCount => _storedViewIds.Count;

		private void Awake()
		{
			_cart = ((Component)this).GetComponent<PhysGrabCart>();
			_cartPhotonView = ((Component)this).GetComponent<PhotonView>();
			_roomIndex = PocketDimensionCartRuntime.ReserveRoomIndex();
			BuildRoom();
			PocketDimensionCartRuntime.Register(this);
		}

		private void OnDisable()
		{
			PocketDimensionCartRuntime.Unregister(this);
		}

		private void Update()
		{
			if (PocketDimensionCartRuntime.IsRealLevel && Object.op_Implicit((Object)(object)_cart))
			{
				RefreshSafeCartExitPose();
				UpdateLocalInput();
			}
		}

		private Vector3 GetCartExitPosition()
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: 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_0024: 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_003c: 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_0047: 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_0057: 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_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			Vector3 flatCartForward = GetFlatCartForward();
			Vector3 val = (Object.op_Implicit((Object)(object)_cart.inCart) ? _cart.inCart.position : ((Component)_cart).transform.position);
			Vector3 position = val + Vector3.up * 1.45f + flatCartForward * 1.25f;
			return SnapExitAboveFloor(position);
		}

		private Quaternion GetCartExitRotation()
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//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)
			return Quaternion.LookRotation(GetFlatCartForward(), Vector3.up);
		}

		private Vector3 GetFlatCartForward()
		{
			//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)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: 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_0047: 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_006d: 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)
			if (!Object.op_Implicit((Object)(object)_cart))
			{
				return Vector3.forward;
			}
			Vector3 val = Vector3.ProjectOnPlane(((Component)_cart).transform.forward, Vector3.up);
			if (((Vector3)(ref val)).sqrMagnitude < 0.001f)
			{
				val = Vector3.ProjectOnPlane(((Component)_cart).transform.right, Vector3.up);
			}
			if (!(((Vector3)(ref val)).sqrMagnitude < 0.001f))
			{
				return ((Vector3)(ref val)).normalized;
			}
			return Vector3.forward;
		}

		private static Vector3 SnapExitAboveFloor(Vector3 position)
		{
			//IL_003c: 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_0047: 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_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: 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)
			int num = LayerMask.GetMask(new string[3] { "Default", "PhysGrabObjectCart", "StaticGrabObject" });
			if (num == 0)
			{
				num = ~LayerMask.GetMask(new string[1] { "Ignore Raycast" });
			}
			Vector3 val = position + Vector3.up * 1.5f;
			RaycastHit val2 = default(RaycastHit);
			if (Physics.Raycast(val, Vector3.down, ref val2, 4.5f, num, (QueryTriggerInteraction)1))
			{
				position.y = Mathf.Max(position.y, ((RaycastHit)(ref val2)).point.y + 1.15f);
			}
			return position;
		}

		private void GetCartExitPose(out Vector3 position, out Quaternion rotation)
		{
			//IL_0019: 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_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_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_0075: 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_0047: 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_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)
			if (CartCanOpenPocket())
			{
				RefreshSafeCartExitPose(force: true);
			}
			if (_lastSafeCartExitValid)
			{
				position = _lastSafeCartExitPosition;
				rotation = _lastSafeCartExitRotation;
			}
			else if (Object.op_Implicit((Object)(object)TruckSafetySpawnPoint.instance))
			{
				position = ((Component)TruckSafetySpawnPoint.instance).transform.position;
				rotation = ((Component)TruckSafetySpawnPoint.instance).transform.rotation;
			}
			else
			{
				position = GetCartExitPosition();
				rotation = GetCartExitRotation();
			}
		}

		private void RefreshSafeCartExitPose(bool force = false)
		{
			//IL_002d: 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_0039: 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)
			if (force || !(Time.time < _nextSafePoseRefreshTime))
			{
				_nextSafePoseRefreshTime = Time.time + 0.25f;
				if (CartCanOpenPocket())
				{
					_lastSafeCartExitPosition = GetCartExitPosition();
					_lastSafeCartExitRotation = GetCartExitRotation();
					_lastSafeCartExitValid = true;
				}
			}
		}

		public void RequestLeave(PlayerAvatar player)
		{
			if (!Object.op_Implicit((Object)(object)player) || Time.time < _nextLocalExitTime)
			{
				return;
			}
			_nextLocalExitTime = Time.time + 1f;
			if (SemiFunc.IsMultiplayer() && Object.op_Implicit((Object)(object)_cartPhotonView) && _cartPhotonView.ViewID != 0)
			{
				int playerViewId = GetPlayerViewId(player);
				if (playerViewId != 0)
				{
					_cartPhotonView.RPC("PocketDimensionRequestLeave", (RpcTarget)2, new object[1] { playerViewId });
				}
			}
			else
			{
				LeaveRoom(player);
			}
		}

		private void UpdateLocalInput()
		{
			PlayerAvatar val = SemiFunc.PlayerGetLocal();
			if (!Object.op_Implicit((Object)(object)val) || val.isDisabled || !SemiFunc.NoTextInputsActive())
			{
				return;
			}
			if (LocalPlayerCanUseCart(val, out var insideCart))
			{
				ShowCartText();
				HandleActionKey(val);
				HandleInteractEnter(val);
			}
			if (PocketDimensionCartPlugin.EnterByHoppingInCart.Value && insideCart && Time.time >= _nextLocalEnterTime && !SemiFunc.InputHold((InputKey)10))
			{
				_insideCartTimer += Time.deltaTime;
				if (_insideCartTimer >= 0.45f)
				{
					_nextLocalEnterTime = Time.time + 2f;
					_insideCartTimer = 0f;
					RequestEnter(val);
				}
			}
			else
			{
				_insideCartTimer = 0f;
			}
			if (LocalPlayerInsideRoom(val))
			{
				PocketDimensionCartAccess.SuppressPocketRoomMovement(PlayerController.instance, val);
				HandleRoomExit(val);
			}
		}

		private void HandleActionKey(PlayerAvatar player)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: 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_0025: 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)
			KeyCode value = PocketDimensionCartPlugin.ActionKey.Value;
			if (Input.GetKeyDown(value))
			{
				_keyDownTime = Time.time;
				_holdRequestSent = false;
			}
			if (Input.GetKey(value) && !_holdRequestSent && Time.time - _keyDownTime >= PocketDimensionCartPlugin.HoldSeconds.Value)
			{
				_holdRequestSent = true;
				RequestEjectAll(player);
			}
			if (Input.GetKeyUp(value))
			{
				if (!_holdRequestSent)
				{
					RequestEjectOne(player);
				}
				_holdRequestSent = false;
			}
		}

		private void HandleInteractEnter(PlayerAvatar player)
		{
			if (!(Time.time < _nextLocalEnterTime) && SemiFunc.InputDown((InputKey)2))
			{
				_nextLocalEnterTime = Time.time + 2f;
				RequestEnter(player);
			}
		}

		private void HandleRoomExit(PlayerAvatar player)
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			if (!PlayerTouchingExit(player))
			{
				_exitTouchTimer = 0f;
				return;
			}
			_exitTouchTimer += Time.deltaTime;
			ApplyExitPortalBrake(player);
			SemiFunc.UIFocusText("Leaving pocket dimension", Color.white, GetFocusFlashColor(), 0.1f);
			if (_exitTouchTimer >= 0.18f)
			{
				_exitTouchTimer = 0f;
				RequestLeave(player);
			}
		}

		private void ShowCartText()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: 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_004c: Unknown result type (might be due to invalid IL or missing references)
			KeyCode value = PocketDimensionCartPlugin.ActionKey.Value;
			string text = ((object)(KeyCode)(ref value)).ToString();
			string text2 = "Press " + text + " to pop out one valuable\nHold " + text + " to pop out all valuables";
			SemiFunc.UIFocusText(text2, Color.white, GetFocusFlashColor(), 0.1f);
		}

		private void RequestEjectOne(PlayerAvatar player)
		{
			if (SemiFunc.IsMultiplayer() && Object.op_Implicit((Object)(object)_cartPhotonView) && _cartPhotonView.ViewID != 0)
			{
				int playerViewId = GetPlayerViewId(player);
				if (playerViewId != 0)
				{
					_cartPhotonView.RPC("PocketDimensionRequestEjectOne", (RpcTarget)2, new object[1] { playerViewId });
				}
			}
			else
			{
				EjectOne(player);
			}
		}

		private void RequestEjectAll(PlayerAvatar player)
		{
			if (SemiFunc.IsMultiplayer() && Object.op_Implicit((Object)(object)_cartPhotonView) && _cartPhotonView.ViewID != 0)
			{
				int playerViewId = GetPlayerViewId(player);
				if (playerViewId != 0)
				{
					_cartPhotonView.RPC("PocketDimensionRequestEjectAll", (RpcTarget)2, new object[1] { playerViewId });
				}
			}
			else
			{
				EjectAll(player);
			}
		}

		private void RequestEnter(PlayerAvatar player)
		{
			if (SemiFunc.IsMultiplayer() && Object.op_Implicit((Object)(object)_cartPhotonView) && _cartPhotonView.ViewID != 0)
			{
				int playerViewId = GetPlayerViewId(player);
				if (playerViewId != 0)
				{
					_cartPhotonView.RPC("PocketDimensionRequestEnter", (RpcTarget)2, new object[1] { playerViewId });
				}
			}
			else
			{
				EnterRoom(player);
			}
		}

		[PunRPC]
		private void PocketDimensionRequestEjectOne(int playerViewId, PhotonMessageInfo info = default(PhotonMessageInfo))
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			if (SemiFunc.IsMasterClientOrSingleplayer() && RequestOwnerIsValid(playerViewId, info))
			{
				PlayerAvatar player = GetPlayer(playerViewId);
				EjectOne(player);
			}
		}

		[PunRPC]
		private void PocketDimensionRequestEjectAll(int playerViewId, PhotonMessageInfo info = default(PhotonMessageInfo))
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			if (SemiFunc.IsMasterClientOrSingleplayer() && RequestOwnerIsValid(playerViewId, info))
			{
				PlayerAvatar player = GetPlayer(playerViewId);
				EjectAll(player);
			}
		}

		[PunRPC]
		private void PocketDimensionRequestEnter(int playerViewId, PhotonMessageInfo info = default(PhotonMessageInfo))
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			if (SemiFunc.IsMasterClientOrSingleplayer() && RequestOwnerIsValid(playerViewId, info))
			{
				PlayerAvatar player = GetPlayer(playerViewId);
				EnterRoom(player);
			}
		}

		[PunRPC]
		private void PocketDimensionRequestLeave(int playerViewId, PhotonMessageInfo info = default(PhotonMessageInfo))
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			if (SemiFunc.IsMasterClientOrSingleplayer() && RequestOwnerIsValid(playerViewId, info))
			{
				PlayerAvatar player = GetPlayer(playerViewId);
				LeaveRoom(player);
			}
		}

		[PunRPC]
		private void PocketDimensionStabilizeExit(int playerViewId, Vector3 exitPosition, Quaternion exitRotation, PhotonMessageInfo info = default(PhotonMessageInfo))
		{
			//IL_0007: 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)
			if (SemiFunc.IsMultiplayer() && info.Sender != PhotonNetwork.MasterClient)
			{
				return;
			}
			PlayerAvatar player = GetPlayer(playerViewId);
			if (!((Object)(object)player == (Object)null))
			{
				StabilizePlayerAfterPocketExit(player, exitPosition, exitRotation);
				RoomVolumeCheck roomVolumeCheck = player.RoomVolumeCheck;
				if (roomVolumeCheck != null)
				{
					roomVolumeCheck.CheckSet();
				}
			}
		}

		private void EnterRoom(PlayerAvatar? player)
		{
			//IL_001c: 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_002b: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)player == (Object)null) && CanPlayerUseCartOnHost(player))
			{
				RefreshSafeCartExitPose(force: true);
				player.Spawn(_playerSpawnPosition, Quaternion.LookRotation(Vector3.forward, Vector3.up));
				RoomVolumeCheck roomVolumeCheck = player.RoomVolumeCheck;
				if (roomVolumeCheck != null)
				{
					roomVolumeCheck.CheckSet();
				}
			}
		}

		private void LeaveRoom(PlayerAvatar? player)
		{
			//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_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)player == (Object)null))
			{
				GetCartExitPose(out var position, out var rotation);
				player.Spawn(position, rotation);
				BroadcastExitStabilize(player, position, rotation);
				RoomVolumeCheck roomVolumeCheck = player.RoomVolumeCheck;
				if (roomVolumeCheck != null)
				{
					roomVolumeCheck.CheckSet();
				}
			}
		}

		private void StabilizePlayerAfterPocketExit(PlayerAvatar player, Vector3 position, Quaternion rotation)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: 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_0034: 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_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_00a2: 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_00b4: 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_00ec: Unknown result type (might be due to invalid IL or missing references)
			player.FallDamageResetSet(2f);
			Rigidbody component = ((Component)player).GetComponent<Rigidbody>();
			if (Object.op_Implicit((Object)(object)component))
			{
				component.position = position;
				component.rotation = rotation;
				component.velocity = Vector3.zero;
				component.angularVelocity = Vector3.zero;
			}
			PlayerTumble tumble = PocketDimensionCartAccess.GetTumble(player);
			if ((Object)(object)tumble != (Object)null)
			{
				tumble.TumbleRequest(false, false);
				tumble.TumbleOverrideTime(0.25f);
				tumble.DisableCustomGravity(0.25f);
				tumble.OverrideDisableTumbleMoveSound(0.25f);
				Rigidbody component2 = ((Component)tumble).GetComponent<Rigidbody>();
				if (Object.op_Implicit((Object)(object)component2))
				{
					component2.position = position + Vector3.up * 0.3f;
					component2.rotation = rotation;
					component2.velocity = Vector3.zero;
					component2.angularVelocity = Vector3.zero;
				}
			}
			if (PocketDimensionCartAccess.IsLocal(player) && Object.op_Implicit((Object)(object)PlayerController.instance))
			{
				((Component)PlayerController.instance).transform.position = position;
				((Component)PlayerController.instance).transform.rotation = rotation;
			}
		}

		private void BroadcastExitStabilize(PlayerAvatar player, Vector3 position, Quaternion rotation)
		{
			//IL_000d: 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_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: 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)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			int playerViewId = GetPlayerViewId(player);
			if (playerViewId == 0)
			{
				StabilizePlayerAfterPocketExit(player, position, rotation);
			}
			else if (SemiFunc.IsMultiplayer() && Object.op_Implicit((Object)(object)_cartPhotonView) && _cartPhotonView.ViewID != 0)
			{
				_cartPhotonView.RPC("PocketDimensionStabilizeExit", (RpcTarget)0, new object[3] { playerViewId, position, rotation });
			}
			else
			{
				PocketDimensionStabilizeExit(playerViewId, position, rotation);
			}
		}

		private void ApplyExitPortalBrake(PlayerAvatar player)
		{
			DampenBody(((Component)player).GetComponent<Rigidbody>(), 0.15f);
			PlayerTumble tumble = PocketDimensionCartAccess.GetTumble(player);
			if ((Object)(object)tumble != (Object)null)
			{
				DampenBody(((Component)tumble).GetComponent<Rigidbody>(), 0.08f);
				tumble.DisableCustomGravity(0.12f);
				tumble.OverrideDisableTumbleMoveSound(0.12f);
			}
			if (PocketDimensionCartAccess.IsLocal(player) && Object.op_Implicit((Object)(object)PlayerController.instance))
			{
				DampenBody(((Component)PlayerController.instance).GetComponent<Rigidbody>(), 0.15f);
			}
		}

		private static void DampenBody(Rigidbody body, float upwardLimit)
		{
			//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_003a: 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_005c: 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)
			if (Object.op_Implicit((Object)(object)body) && !body.isKinematic)
			{
				Vector3 velocity = body.velocity;
				velocity.x *= 0.25f;
				velocity.z *= 0.25f;
				velocity.y = Mathf.Clamp(velocity.y * 0.2f, 0f - upwardLimit, upwardLimit);
				body.velocity = velocity;
				body.angularVelocity *= 0.15f;
			}
		}

		private bool CartCanOpenPocket()
		{
			if (!Object.op_Implicit((Object)(object)_cart) || !((Component)_cart).gameObject.activeInHierarchy || !Object.op_Implicit((Object)(object)((Component)_cart).GetComponent<PhysGrabObject>()))
			{
				return false;
			}
			return !PocketDimensionCartAccess.IsEquippedOrInInventory(((Component)_cart).GetComponent<ItemEquippable>());
		}

		private bool LocalPlayerCanUseCart(PlayerAvatar player, out bool insideCart)
		{
			//IL_004c: 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_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			if (!CartCanOpenPocket())
			{
				insideCart = false;
				return false;
			}
			insideCart = PlayerInsideCartVolume(player);
			if (insideCart)
			{
				return true;
			}
			if (Object.op_Implicit((Object)(object)PhysGrabber.instance) && (Object)(object)PhysGrabber.instance.grabbedPhysGrabObject == (Object)(object)_cart.physGrabObject)
			{
				return true;
			}
			if (Vector3.Distance(((Component)player).transform.position, ((Component)_cart).transform.position) > 5.5f)
			{
				return false;
			}
			Transform aimTransform = GetAimTransform(player);
			if (!Object.op_Implicit((Object)(object)aimTransform))
			{
				return false;
			}
			Ray val = default(Ray);
			((Ray)(ref val))..ctor(aimTransform.position, aimTransform.forward);
			RaycastHit val2 = default(RaycastHit);
			if (!Physics.Raycast(val, ref val2, 6f, -1, (QueryTriggerInteraction)2))
			{
				return false;
			}
			PhysGrabCart componentInParent = ((Component)((RaycastHit)(ref val2)).collider).GetComponentInParent<PhysGrabCart>();
			return (Object)(object)componentInParent == (Object)(object)_cart;
		}

		private bool PlayerInsideCartVolume(PlayerAvatar player)
		{
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: 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_0059: 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_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_0094: 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)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: 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_0069: 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_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: 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)
			if (!Object.op_Implicit((Object)(object)player) || !Object.op_Implicit((Object)(object)_cart) || !Object.op_Implicit((Object)(object)_cart.inCart))
			{
				return false;
			}
			BoxCollider component = ((Component)_cart.inCart).GetComponent<BoxCollider>();
			Vector3 val = ((Component)player).transform.position + Vector3.up * 0.25f;
			if (Object.op_Implicit((Object)(object)component))
			{
				return Vector3.Distance(((Collider)component).ClosestPoint(val), val) < 0.01f;
			}
			Vector3 val2 = _cart.inCart.InverseTransformPoint(val);
			Vector3 val3 = _cart.inCart.localScale * 0.5f;
			if (Mathf.Abs(val2.x) <= val3.x && Mathf.Abs(val2.y) <= val3.y)
			{
				return Mathf.Abs(val2.z) <= val3.z;
			}
			return false;
		}

		private bool CanPlayerUseCartOnHost(PlayerAvatar? player)
		{
			//IL_003a: 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)
			if (!PocketDimensionCartRuntime.IsRealLevel || (Object)(object)player == (Object)null || !Object.op_Implicit((Object)(object)_cart))
			{
				return false;
			}
			if (LocalOrHostPlayerInsideRoom(player))
			{
				return true;
			}
			if (!CartCanOpenPocket())
			{
				return false;
			}
			if (!(Vector3.Distance(((Component)player).transform.position, ((Component)_cart).transform.position) <= 8f))
			{
				return PlayerInsideCartVolume(player);
			}
			return true;
		}

		private bool LocalPlayerInsideRoom(PlayerAvatar? player)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)player != (Object)null && Vector3.Distance(((Component)player).transform.position, _roomOrigin) <= 14f)
			{
				return Mathf.Abs(((Component)player).transform.position.y - _roomOrigin.y) <= 8f;
			}
			return false;
		}

		internal bool PlayerInsidePocketRoom(PlayerAvatar? player)
		{
			return LocalPlayerInsideRoom(player);
		}

		private bool LocalOrHostPlayerInsideRoom(PlayerAvatar? player)
		{
			return LocalPlayerInsideRoom(player);
		}

		private bool PlayerTouchingExit(PlayerAvatar player)
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: 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_0031: 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_003d: 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_0058: 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_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: 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)
			if (!Object.op_Implicit((Object)(object)player) || !Object.op_Implicit((Object)(object)_exitCollider))
			{
				return false;
			}
			Vector3 val = ((Component)player).transform.position + Vector3.up * 0.35f;
			if (Vector3.Distance(_exitCollider.ClosestPoint(val), val) < 0.04f)
			{
				return true;
			}
			Vector3 val2 = ((Component)player).transform.position + Vector3.up * 1.1f;
			return Vector3.Distance(_exitCollider.ClosestPoint(val2), val2) < 0.04f;
		}

		private Transform GetAimTransform(PlayerAvatar player)
		{
			if (Object.op_Implicit((Object)(object)player.localCamera))
			{
				return player.localCamera.GetOverrideTransform();
			}
			Camera main = Camera.main;
			if (!Object.op_Implicit((Object)(object)main))
			{
				return ((Component)player).transform;
			}
			return ((Component)main).transform;
		}

		private int GetPlayerViewId(PlayerAvatar player)
		{
			if (!Object.op_Implicit((Object)(object)player) || !Object.op_Implicit((Object)(object)player.photonView))
			{
				return 0;
			}
			return player.photonView.ViewID;
		}

		private PlayerAvatar? GetPlayer(int playerViewId)
		{
			PhotonView val = PhotonView.Find(playerViewId);
			if (!Object.op_Implicit((Object)(object)val))
			{
				return null;
			}
			return ((Component)val).GetComponent<PlayerAvatar>();
		}

		private PhysGrabObject? GetPhysGrabObject(int viewId)
		{
			return PocketDimensionCartRuntime.ResolvePhysGrabObject(viewId);
		}

		private bool RequestOwnerIsValid(int playerViewId, PhotonMessageInfo info)
		{
			//IL_0020: 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_0036: Unknown result type (might be due to invalid IL or missing references)
			if (!SemiFunc.IsMultiplayer())
			{
				return true;
			}
			PhotonView val = PhotonView.Find(playerViewId);
			if (!Object.op_Implicit((Object)(object)val))
			{
				return false;
			}
			if (val.Owner != info.Sender && val.Controller != info.Sender)
			{
				return info.Sender == PhotonNetwork.MasterClient;
			}
			return true;
		}

		private Color GetFocusFlashColor()
		{
			//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_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)
			try
			{
				if (Object.op_Implicit((Object)(object)AssetManager.instance))
				{
					return AssetManager.instance.colorYellow;
				}
			}
			catch
			{
			}
			return new Color(0.95f, 0.68f, 1f, 1f);
		}

		private void BuildRoom()
		{
			//IL_0047: 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_0053: 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_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: 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_0096: 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_00b1: 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_00bb: 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)
			//IL_00db: Expected O, but got Unknown
			//IL_00e2: 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_00fb: 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_0128: Unknown result type (might be due to invalid IL or missing references)
			//IL_013b: Unknown result type (might be due to invalid IL or missing references)
			//IL_014f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0154: Unknown result type (might be due to invalid IL or missing references)
			//IL_0168: Unknown result type (might be due to invalid IL or missing references)
			//IL_0181: Unknown result type (might be due to invalid IL or missing references)
			//IL_0194: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01da: 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_0201: 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_021a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0233: 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_025a: Unknown result type (might be due to invalid IL or missing references)
			//IL_025f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0273: 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_029f: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02cc: Unknown result type (might be due to invalid IL or missing references)
			int num = ((Object.op_Implicit((Object)(object)_cartPhotonView) && _cartPhotonView.ViewID != 0) ? _cartPhotonView.ViewID : _roomIndex);
			_roomOrigin = new Vector3(10000f + (float)num * 35f, 4000f, 10000f);
			_playerSpawnPosition = _roomOrigin + new Vector3(0f, 1.5f, 6f);
			_playerExitPosition = _roomOrigin + new Vector3(0f, 1.5f, 8.4f);
			_valuableExitPosition = _playerExitPosition + new Vector3(0f, 0.5f, 0f);
			_roomRoot = new GameObject($"Pocket Dimension Cart Room {num}");
			CreateRoomBlock("Floor", _roomOrigin + new Vector3(0f, -0.1f, 0f), new Vector3(18f, 0.2f, 18f), new Color(0.12f, 0.08f, 0.18f, 1f), trigger: false);
			CreateRoomBlock("North Wall", _roomOrigin + new Vector3(0f, 3f, 9f), new Vector3(18f, 6f, 0.3f), new Color(0.16f, 0.1f, 0.24f, 1f), trigger: false);
			CreateRoomBlock("South Wall", _roomOrigin + new Vector3(0f, 3f, -9f), new Vector3(18f, 6f, 0.3f), new Color(0.16f, 0.1f, 0.24f, 1f), trigger: false);
			CreateRoomBlock("East Wall", _roomOrigin + new Vector3(9f, 3f, 0f), new Vector3(0.3f, 6f, 18f), new Color(0.16f, 0.1f, 0.24f, 1f), trigger: false);
			CreateRoomBlock("West Wall", _roomOrigin + new Vector3(-9f, 3f, 0f), new Vector3(0.3f, 6f, 18f), new Color(0.16f, 0.1f, 0.24f, 1f), trigger: false);
			GameObject val = CreateRoomBlock("Pocket Exit", _valuableExitPosition, new Vector3(4.5f, 3.2f, 2.2f), new Color(0.3f, 0.8f, 1f, 0.35f), trigger: true);
			_exitCollider = val.GetComponent<Collider>();
			val.AddComponent<PocketDimensionValuableExitZone>().SetController(this);
		}

		private GameObject CreateRoomBlock(string name, Vector3 position, Vector3 scale, Color color, bool trigger)
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Expected O, but got Unknown
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = GameObject.CreatePrimitive((PrimitiveType)3);
			((Object)val).name = name;
			val.transform.SetParent(_roomRoot.transform);
			val.transform.position = position;
			val.transform.localScale = scale;
			Collider component = val.GetComponent<Collider>();
			component.isTrigger = trigger;
			Renderer component2 = val.GetComponent<Renderer>();
			if (Object.op_Implicit((Object)(object)component2))
			{
				Shader val2 = Shader.Find("Universal Render Pipeline/Lit");
				if (!Object.op_Implicit((Object)(object)val2))
				{
					val2 = Shader.Find("Standard");
				}
				if (Object.op_Implicit((Object)(object)val2))
				{
					Material val3 = new Material(val2);
					val3.color = color;
					component2.material = val3;
				}
			}
			int num = LayerMask.NameToLayer("Default");
			if (num >= 0)
			{
				val.layer = num;
			}
			return val;
		}

		public bool OwnsStoredValuable(PhysGrabObject physGrabObject)
		{
			int viewId = PocketDimensionCartRuntime.GetViewId(physGrabObject);
			if (viewId != 0)
			{
				return _storedViewIds.Contains(viewId);
			}
			return false;
		}

		public void StoreValuable(PhysGrabObject physGrabObject)
		{
			//IL_00b9: 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)
			if (!PocketDimensionCartRuntime.IsRealLevel || !SemiFunc.IsMasterClientOrSingleplayer() || !CartCanOpenPocket() || !Object.op_Implicit((Object)(object)physGrabObject) || !Object.op_Implicit((Object)(object)((Component)physGrabObject).GetComponent<ValuableObject>()) || physGrabObject.grabbed || physGrabObject.playerGrabbing.Count > 0 || !PocketDimensionCartRuntime.CanAbsorb(physGrabObject))
			{
				return;
			}
			int viewId = PocketDimensionCartRuntime.GetViewId(physGrabObject);
			if (viewId != 0 && !_storedViewIds.Contains(viewId))
			{
				_storedViewIds.Add(viewId);
				PocketDimensionCartRuntime.MarkStored(physGrabObject, this);
				PocketDimensionStoredValuable pocketDimensionStoredValuable = ((Component)physGrabObject).GetComponent<PocketDimensionStoredValuable>();
				if (!Object.op_Implicit((Object)(object)pocketDimensionStoredValuable))
				{
					pocketDimensionStoredValuable = ((Component)physGrabObject).gameObject.AddComponent<PocketDimensionStoredValuable>();
				}
				pocketDimensionStoredValuable.SetStored(this);
				ResetCartState(physGrabObject);
				PocketDimensionCartRuntime.ProtectValuable(physGrabObject, 0.75f);
				PocketDimensionCartRuntime.TeleportPhysGrabObject(physGrabObject, GetStoragePosition(_storedViewIds.Count - 1), Quaternion.identity);
				SyncStoredTotals();
			}
		}

		public void EjectStoredFromRoom(PhysGrabObject physGrabObject)
		{
			if (SemiFunc.IsMasterClientOrSingleplayer() && OwnsStoredValuable(physGrabObject))
			{
				EjectValuable(physGrabObject);
			}
		}

		private void EjectOne(PlayerAvatar? player)
		{
			if (CanPlayerUseCartOnHost(player))
			{
				PhysGrabObject val = FindStoredValuable(preferReleased: true);
				if ((Object)(object)val != (Object)null)
				{
					EjectValuable(val);
				}
			}
		}

		private void EjectAll(PlayerAvatar? player)
		{
			if (CanPlayerUseCartOnHost(player) && !_ejectAllRunning)
			{
				((MonoBehaviour)this).StartCoroutine(EjectAllRoutine());
			}
		}

		private IEnumerator EjectAllRoutine()
		{
			_ejectAllRunning = true;
			while (_storedViewIds.Count > 0)
			{
				PhysGrabObject val = FindStoredValuable(preferReleased: true);
				if ((Object)(object)val == (Object)null)
				{
					CleanupStoredList();
					break;
				}
				EjectValuable(val);
				yield return (object)new WaitForSeconds(Mathf.Max(0.05f, PocketDimensionCartPlugin.EjectStaggerSeconds.Value));
			}
			_ejectAllRunning = false;
		}

		private void EjectValuable(PhysGrabObject physGrabObject)
		{
			//IL_00d3: 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)
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: Unknown result type (might be due to invalid IL or missing references)
			//IL_011d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_0132: Unknown result type (might be due to invalid IL or missing references)
			if (!Object.op_Implicit((Object)(object)physGrabObject))
			{
				return;
			}
			int viewId = PocketDimensionCartRuntime.GetViewId(physGrabObject);
			_storedViewIds.Remove(viewId);
			PocketDimensionCartRuntime.MarkReleased(physGrabObject, PocketDimensionCartPlugin.EjectCooldownSeconds.Value);
			SyncStoredTotals();
			int num = ((viewId > 0) ? viewId : (-1));
			foreach (PhysGrabber item in physGrabObject.playerGrabbing.ToList())
			{
				if (Object.op_Implicit((Object)(object)item))
				{
					item.ReleaseObject(num, 0.35f);
				}
			}
			physGrabObject.OverrideGrabDisable(0.35f);
			PocketDimensionStoredValuable component = ((Component)physGrabObject).GetComponent<PocketDimensionStoredValuable>();
			if (Object.op_Implicit((Object)(object)component))
			{
				component.SetReleased(PocketDimensionCartPlugin.EjectedProtectionSeconds.Value);
			}
			ResetCartState(physGrabObject);
			GetCartExitPose(out var position, out var rotation);
			PocketDimensionCartRuntime.ProtectValuable(physGrabObject, PocketDimensionCartPlugin.EjectedProtectionSeconds.Value);
			PocketDimensionCartRuntime.TeleportPhysGrabObject(physGrabObject, position, rotation);
			if (Object.op_Implicit((Object)(object)physGrabObject.rb))
			{
				physGrabObject.rb.velocity = ((Component)_cart).transform.up * 1.4f + ((Component)_cart).transform.forward * 0.7f;
				physGrabObject.rb.angularVelocity = Vector3.zero;
				physGrabObject.rb.WakeUp();
			}
		}

		public void AddStoredContentsToCartReadout()
		{
			if (Object.op_Implicit((Object)(object)_cart))
			{
				if (SemiFunc.IsMasterClientOrSingleplayer())
				{
					RefreshStoredTotals();
				}
				if (_syncedStoredCount > 0 || _syncedStoredValue > 0)
				{
					PhysGrabCart cart = _cart;
					cart.itemsInCartCount += _syncedStoredCount;
					PhysGrabCart cart2 = _cart;
					cart2.haulCurrent += _syncedStoredValue;
				}
			}
		}

		public int AddStoredValueToDisplay(int baseValue)
		{
			if (SemiFunc.IsMasterClientOrSingleplayer())
			{
				RefreshStoredTotals();
			}
			return Mathf.Max(0, baseValue + _syncedStoredValue);
		}

		public bool UsesValueScreen(ValueScreen valueScreen)
		{
			if (Object.op_Implicit((Object)(object)_cart))
			{
				return (Object)(object)_cart.valueScreen == (Object)(object)valueScreen;
			}
			return false;
		}

		private void SyncStoredTotals()
		{
			//IL_006a: 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)
			RefreshStoredTotals();
			if (SemiFunc.IsMultiplayer() && Object.op_Implicit((Object)(object)_cartPhotonView) && _cartPhotonView.ViewID != 0)
			{
				_cartPhotonView.RPC("PocketDimensionSyncStoredTotals", (RpcTarget)0, new object[2] { _syncedStoredCount, _syncedStoredValue });
			}
			else
			{
				PocketDimensionSyncStoredTotals(_syncedStoredCount, _syncedStoredValue);
			}
		}

		private void RefreshStoredTotals()
		{
			CleanupStoredList();
			int num = 0;
			int num2 = 0;
			foreach (int storedViewId in _storedViewIds)
			{
				PhysGrabObject physGrabObject = GetPhysGrabObject(storedViewId);
				if (!((Object)(object)physGrabObject == (Object)null))
				{
					num++;
					ValuableObject component = ((Component)physGrabObject).GetComponent<ValuableObject>();
					if (Object.op_Implicit((Object)(object)component))
					{
						num2 += (int)component.dollarValueCurrent;
					}
				}
			}
			_syncedStoredCount = num;
			_syncedStoredValue = num2;
		}

		[PunRPC]
		private void PocketDimensionSyncStoredTotals(int count, int value, PhotonMessageInfo info = default(PhotonMessageInfo))
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			if (!SemiFunc.IsMultiplayer() || info.Sender == PhotonNetwork.MasterClient)
			{
				_syncedStoredCount = Mathf.Max(0, count);
				_syncedStoredValue = Mathf.Max(0, value);
			}
		}

		private PhysGrabObject? FindStoredValuable(bool preferReleased)
		{
			CleanupStoredList();
			foreach (int storedViewId in _storedViewIds)
			{
				PhysGrabObject physGrabObject = GetPhysGrabObject(storedViewId);
				if ((Object)(object)physGrabObject != (Object)null && (!preferReleased || (!physGrabObject.grabbed && physGrabObject.playerGrabbing.Count == 0)))
				{
					return physGrabObject;
				}
			}
			foreach (int storedViewId2 in _storedViewIds)
			{
				PhysGrabObject physGrabObject2 = GetPhysGrabObject(storedViewId2);
				if ((Object)(object)physGrabObject2 != (Object)null)
				{
					return physGrabObject2;
				}
			}
			return null;
		}

		private void CleanupStoredList()
		{
			for (int num = _storedViewIds.Count - 1; num >= 0; num--)
			{
				if (!Object.op_Implicit((Object)(object)GetPhysGrabObject(_storedViewIds[num])))
				{
					_storedViewIds.RemoveAt(num);
				}
			}
		}

		private Vector3 GetStoragePosition(int index)
		{
			//IL_0009: 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_0030: Unknown result type (might be due to invalid IL or missing references)
			int num = index % 5;
			int num2 = index / 5;
			return _roomOrigin + new Vector3((float)(num - 2) * 2.4f, 1.2f, -4.8f + (float)num2 * 2.4f);
		}

		private static void ResetCartState(PhysGrabObject physGrabObject)
		{
			if (Object.op_Implicit((Object)(object)physGrabObject) && Object.op_Implicit((Object)(object)physGrabObject.impactDetector))
			{
				PhysGrabObjectImpactDetector impactDetector = physGrabObject.impactDetector;
				impactDetector.timerInCart = 0f;
				impactDetector.inCart = false;
				impactDetector.currentCart = null;
				impactDetector.currentCartPrev = null;
				impactDetector.ImpactDisable(0.25f);
			}
		}
	}
	[BepInPlugin("empress.repo.pocketdimensioncart", "Pocket Dimension Cart", "1.3.0")]
	public sealed class PocketDimensionCartPlugin : BaseUnityPlugin
	{
		public const string PluginGuid = "empress.repo.pocketdimensioncart";

		public const string PluginName = "Pocket Dimension Cart";

		public const string PluginVersion = "1.3.0";

		internal static PocketDimensionCartPlugin Instance;

		internal static ConfigEntry<KeyCode> ActionKey;

		internal static ConfigEntry<float> HoldSeconds;

		internal static ConfigEntry<float> EjectStaggerSeconds;

		internal static ConfigEntry<float> EjectCooldownSeconds;

		internal static ConfigEntry<float> EjectedProtectionSeconds;

		internal static ConfigEntry<bool> EnterByHoppingInCart;

		private Harmony _harmony;

		private void Awake()
		{
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Expected O, but got Unknown
			Instance = this;
			ActionKey = ((BaseUnityPlugin)this).Config.Bind<KeyCode>("Input", "ActionKey", (KeyCode)120, "Press near a cart to eject one stored valuable. Hold to eject all stored valuables.");
			HoldSeconds = ((BaseUnityPlugin)this).Config.Bind<float>("Input", "HoldSeconds", 0.55f, "How long the action key must be held before eject-all starts.");
			EjectStaggerSeconds = ((BaseUnityPlugin)this).Config.Bind<float>("Cart", "EjectStaggerSeconds", 0.18f, "Delay between each valuable when ejecting all.");
			EjectCooldownSeconds = ((BaseUnityPlugin)this).Config.Bind<float>("Cart", "EjectCooldownSeconds", 2f, "How long an ejected valuable is blocked from being absorbed by a cart again.");
			EjectedProtectionSeconds = ((BaseUnityPlugin)this).Config.Bind<float>("Cart", "EjectedProtectionSeconds", 2f, "Temporary damage protection after a valuable exits the pocket dimension.");
			EnterByHoppingInCart = ((BaseUnityPlugin)this).Config.Bind<bool>("Cart", "EnterByHoppingInCart", true, "Allows players to enter the pocket dimension by standing inside the cart.");
			_harmony = new Harmony("empress.repo.pocketdimensioncart");
			_harmony.PatchAll();
			((BaseUnityPlugin)this).Logger.LogInfo((object)"Pocket Dimension Cart v1.3.0 loaded.");
		}
	}
	internal sealed class PocketDimensionStoredValuable : MonoBehaviour
	{
		private PhysGrabObject _physGrabObject;

		private PocketDimensionCartController? _owner;

		private float _protectUntil;

		private bool _stored;

		private void Awake()
		{
			_physGrabObject = ((Component)this).GetComponent<PhysGrabObject>();
		}

		private void Update()
		{
			if (Object.op_Implicit((Object)(object)_physGrabObject) && (_stored || Time.time < _protectUntil))
			{
				_physGrabObject.OverrideIndestructible(0.35f);
				_physGrabObject.OverrideBreakEffects(0.35f);
				if (Object.op_Implicit((Object)(object)_physGrabObject.impactDetector))
				{
					_physGrabObject.impactDetector.ImpactDisable(0.35f);
				}
			}
		}

		public void SetStored(PocketDimensionCartController owner)
		{
			_owner = owner;
			_stored = true;
			Protect(1f);
		}

		public void SetReleased(float protectionSeconds)
		{
			_owner = null;
			_stored = false;
			Protect(protectionSeconds);
		}

		public void Protect(float seconds)
		{
			_protectUntil = Mathf.Max(_protectUntil, Time.time + Mathf.Max(0f, seconds));
		}

		public PocketDimensionCartController? GetOwner()
		{
			return _owner;
		}
	}
	internal sealed class PocketDimensionValuableExitZone : MonoBehaviour
	{
		private PocketDimensionCartController _controller;

		public void SetController(PocketDimensionCartController controller)
		{
			_controller = controller;
		}

		private void OnTriggerEnter(Collider other)
		{
			TryEject(other);
		}

		private void OnTriggerStay(Collider other)
		{
			TryEject(other);
		}

		private void TryEject(Collider other)
		{
			if (Object.op_Implicit((Object)(object)_controller) && PocketDimensionCartRuntime.IsRealLevel && SemiFunc.IsMasterClientOrSingleplayer())
			{
				PhysGrabObject componentInParent = ((Component)other).GetComponentInParent<PhysGrabObject>();
				if (Object.op_Implicit((Object)(object)componentInParent) && _controller.OwnsStoredValuable(componentInParent))
				{
					_controller.EjectStoredFromRoom(componentInParent);
				}
			}
		}
	}
	internal static class PocketDimensionCartAccess
	{
		private static readonly FieldRef<ItemEquippable, ItemState>? ItemCurrentState = CreateItemStateRef("currentState") ?? CreateItemStateRef("_currentState");

		private static readonly FieldRef<ItemEquippable, bool>? ItemIsEquipped = CreateBoolRef("isEquipped");

		private static readonly FieldRef<ItemEquippable, bool>? ItemIsEquipping = CreateBoolRef("isEquipping");

		private static readonly FieldRef<ItemEquippable, bool>? ItemIsUnequipping = CreateBoolRef("isUnequipping");

		private static readonly FieldRef<ItemEquippable, InventorySpot>? ItemEquippedSpot = CreateInventorySpotRef("equippedSpot");

		private static readonly FieldRef<PlayerAvatar, PlayerTumble>? PlayerTumbleRef = CreatePlayerTumbleRef("tumble");

		private static readonly FieldRef<PlayerAvatar, bool>? PlayerIsLocalRef = CreatePlayerBoolRef("isLocal");

		private static readonly FieldRef<PlayerAvatar, bool>? PlayerIsSprintingRef = CreatePlayerBoolRef("isSprinting");

		private static readonly FieldRef<PlayerTumble, PlayerAvatar>? TumblePlayerRef = CreateTumblePlayerRef("playerAvatar");

		private static readonly FieldRef<PlayerTumble, bool>? TumbleIsTumblingRef = CreateTumbleBoolRef("isTumbling");

		private static readonly FieldRef<PlayerController, PlayerAvatar>? ControllerPlayerRef = CreateControllerPlayerRef("playerAvatarScript");

		private static readonly FieldRef<PlayerController, bool>? ControllerSprintingRef = CreateControllerBoolRef("sprinting");

		private static readonly FieldRef<PlayerController, bool>? ControllerToggleSprintRef = CreateControllerBoolRef("toggleSprint");

		private static readonly FieldRef<PlayerController, float>? ControllerTumbleInputDisableRef = CreateControllerFloatRef("tumbleInputDisableTimer");

		private static readonly FieldRef<PlayerController, float>? ControllerSprintedTimerRef = CreateControllerFloatRef("SprintedTimer");

		private static readonly FieldRef<PlayerController, float>? ControllerSprintDrainTimerRef = CreateControllerFloatRef("SprintDrainTimer");

		private static readonly FieldRef<PlayerController, float>? ControllerSprintSpeedLerpRef = CreateControllerFloatRef("SprintSpeedLerp");

		internal static bool IsEquippedOrInInventory(ItemEquippable itemEquippable)
		{
			if (!Object.op_Implicit((Object)(object)itemEquippable))
			{
				return false;
			}
			try
			{
				if (itemEquippable.IsEquipped())
				{
					return true;
				}
			}
			catch
			{
			}
			FieldRef<ItemEquippable, ItemState> itemCurrentState = ItemCurrentState;
			if (itemCurrentState != null)
			{
				try
				{
					if (itemCurrentState.Invoke(itemEquippable))
					{
						return true;
					}
				}
				catch
				{
				}
			}
			if (!ReadBool(itemEquippable, ItemIsEquipped) && !ReadBool(itemEquippable, ItemIsEquipping) && !ReadBool(itemEquippable, ItemIsUnequipping))
			{
				return ReadEquippedSpot(itemEquippable);
			}
			return true;
		}

		internal static PlayerTumble? GetTumble(PlayerAvatar player)
		{
			FieldRef<PlayerAvatar, PlayerTumble> playerTumbleRef = PlayerTumbleRef;
			if (playerTumbleRef == null || !Object.op_Implicit((Object)(object)player))
			{
				return null;
			}
			try
			{
				return playerTumbleRef.Invoke(player);
			}
			catch
			{
				return null;
			}
		}

		internal static bool IsLocal(PlayerAvatar player)
		{
			FieldRef<PlayerAvatar, bool> playerIsLocalRef = PlayerIsLocalRef;
			if (playerIsLocalRef == null || !Object.op_Implicit((Object)(object)player))
			{
				return false;
			}
			try
			{
				return playerIsLocalRef.Invoke(player);
			}
			catch
			{
				return false;
			}
		}

		internal static PlayerAvatar? GetTumbleOwner(PlayerTumble tumble)
		{
			FieldRef<PlayerTumble, PlayerAvatar> tumblePlayerRef = TumblePlayerRef;
			if (tumblePlayerRef == null || !Object.op_Implicit((Object)(object)tumble))
			{
				return null;
			}
			try
			{
				return tumblePlayerRef.Invoke(tumble);
			}
			catch
			{
				return null;
			}
		}

		internal static PlayerAvatar? GetControllerPlayer(PlayerController controller)
		{
			FieldRef<PlayerController, PlayerAvatar> controllerPlayerRef = ControllerPlayerRef;
			if (controllerPlayerRef == null || !Object.op_Implicit((Object)(object)controller))
			{
				return null;
			}
			try
			{
				return controllerPlayerRef.Invoke(controller);
			}
			catch
			{
				return null;
			}
		}

		internal static void SuppressPocketRoomMovement(PlayerController? controller, PlayerAvatar player)
		{
			if (!Object.op_Implicit((Object)(object)player))
			{
				return;
			}
			SetPlayerBool(player, PlayerIsSprintingRef, value: false);
			if (Object.op_Implicit((Object)(object)controller))
			{
				SetControllerBool(controller, ControllerSprintingRef, value: false);
				SetControllerBool(controller, ControllerToggleSprintRef, value: false);
				SetControllerFloat(controller, ControllerTumbleInputDisableRef, 0.2f, useMax: true);
				SetControllerFloat(controller, ControllerSprintedTimerRef, 0f, useMax: false);
				SetControllerFloat(controller, ControllerSprintDrainTimerRef, 0f, useMax: false);
				SetControllerFloat(controller, ControllerSprintSpeedLerpRef, 0f, useMax: false);
			}
			PlayerTumble tumble = GetTumble(player);
			if ((Object)(object)tumble != (Object)null)
			{
				if (ReadTumbleBool(tumble, TumbleIsTumblingRef))
				{
					tumble.TumbleRequest(false, false);
				}
				tumble.TumbleOverrideTime(0.2f);
				tumble.DisableCustomGravity(0.1f);
				tumble.OverrideDisableTumbleMoveSound(0.2f);
			}
		}

		private static bool ReadBool(ItemEquippable itemEquippable, FieldRef<ItemEquippable, bool>? accessor)
		{
			if (accessor == null)
			{
				return false;
			}
			try
			{
				return accessor.Invoke(itemEquippable);
			}
			catch
			{
				return false;
			}
		}

		private static bool ReadTumbleBool(PlayerTumble tumble, FieldRef<PlayerTumble, bool>? accessor)
		{
			if (accessor == null)
			{
				return false;
			}
			try
			{
				return accessor.Invoke(tumble);
			}
			catch
			{
				return false;
			}
		}

		private static void SetPlayerBool(PlayerAvatar player, FieldRef<PlayerAvatar, bool>? accessor, bool value)
		{
			if (accessor == null)
			{
				return;
			}
			try
			{
				accessor.Invoke(player) = value;
			}
			catch
			{
			}
		}

		private static void SetControllerBool(PlayerController controller, FieldRef<PlayerController, bool>? accessor, bool value)
		{
			if (accessor == null)
			{
				return;
			}
			try
			{
				accessor.Invoke(controller) = value;
			}
			catch
			{
			}
		}

		private static void SetControllerFloat(PlayerController controller, FieldRef<PlayerController, float>? accessor, float value, bool useMax)
		{
			if (accessor == null)
			{
				return;
			}
			try
			{
				accessor.Invoke(controller) = (useMax ? Mathf.Max(accessor.Invoke(controller), value) : value);
			}
			catch
			{
			}
		}

		private static bool ReadEquippedSpot(ItemEquippable itemEquippable)
		{
			FieldRef<ItemEquippable, InventorySpot> itemEquippedSpot = ItemEquippedSpot;
			if (itemEquippedSpot == null)
			{
				return false;
			}
			try
			{
				InventorySpot val = itemEquippedSpot.Invoke(itemEquippable);
				return Object.op_Implicit((Object)(object)val);
			}
			catch
			{
				return false;
			}
		}

		private static FieldRef<ItemEquippable, ItemState>? CreateItemStateRef(string name)
		{
			try
			{
				return AccessTools.FieldRefAccess<ItemEquippable, ItemState>(name);
			}
			catch
			{
				return null;
			}
		}

		private static FieldRef<ItemEquippable, bool>? CreateBoolRef(string name)
		{
			try
			{
				return AccessTools.FieldRefAccess<ItemEquippable, bool>(name);
			}
			catch
			{
				return null;
			}
		}

		private static FieldRef<ItemEquippable, InventorySpot>? CreateInventorySpotRef(string name)
		{
			try
			{
				return AccessTools.FieldRefAccess<ItemEquippable, InventorySpot>(name);
			}
			catch
			{
				return null;
			}
		}

		private static FieldRef<PlayerAvatar, PlayerTumble>? CreatePlayerTumbleRef(string name)
		{
			try
			{
				return AccessTools.FieldRefAccess<PlayerAvatar, PlayerTumble>(name);
			}
			catch
			{
				return null;
			}
		}

		private static FieldRef<PlayerAvatar, bool>? CreatePlayerBoolRef(string name)
		{
			try
			{
				return AccessTools.FieldRefAccess<PlayerAvatar, bool>(name);
			}
			catch
			{
				return null;
			}
		}

		private static FieldRef<PlayerTumble, PlayerAvatar>? CreateTumblePlayerRef(string name)
		{
			try
			{
				return AccessTools.FieldRefAccess<PlayerTumble, PlayerAvatar>(name);
			}
			catch
			{
				return null;
			}
		}

		private static FieldRef<PlayerTumble, bool>? CreateTumbleBoolRef(string name)
		{
			try
			{
				return AccessTools.FieldRefAccess<PlayerTumble, bool>(name);
			}
			catch
			{
				return null;
			}
		}

		private static FieldRef<PlayerController, PlayerAvatar>? CreateControllerPlayerRef(string name)
		{
			try
			{
				return AccessTools.FieldRefAccess<PlayerController, PlayerAvatar>(name);
			}
			catch
			{
				return null;
			}
		}

		private static FieldRef<PlayerController, bool>? CreateControllerBoolRef(string name)
		{
			try
			{
				return AccessTools.FieldRefAccess<PlayerController, bool>(name);
			}
			catch
			{
				return null;
			}
		}

		private static FieldRef<PlayerController, float>? CreateControllerFloatRef(string name)
		{
			try
			{
				return AccessTools.FieldRefAccess<PlayerController, float>(name);
			}
			catch
			{
				return null;
			}
		}
	}
	internal static class PocketDimensionCartRuntime
	{
		private static readonly List<PocketDimensionCartController> Controllers = new List<PocketDimensionCartController>();

		private static readonly Dictionary<int, PocketDimensionCartController> StoredOwners = new Dictionary<int, PocketDimensionCartController>();

		private static readonly Dictionary<int, float> AbsorbCooldowns = new Dictionary<int, float>();

		private static readonly Dictionary<int, PhysGrabObject> LocalPhysGrabObjects = new Dictionary<int, PhysGrabObject>();

		private static int _nextRoomIndex;

		internal static bool IsRealLevel
		{
			get
			{
				try
				{
					if (!Object.op_Implicit((Object)(object)RunManager.instance) || !Object.op_Implicit((Object)(object)LevelGenerator.Instance) || !LevelGenerator.Instance.Generated)
					{
						return false;
					}
					if (SemiFunc.MenuLevel() || SemiFunc.RunIsShop() || SemiFunc.RunIsTutorial())
					{
						return false;
					}
					return SemiFunc.RunIsLevel();
				}
				catch
				{
					return false;
				}
			}
		}

		internal static bool CanAttachToCart
		{
			get
			{
				try
				{
					if (!Object.op_Implicit((Object)(object)RunManager.instance) || SemiFunc.MenuLevel() || SemiFunc.RunIsShop() || SemiFunc.RunIsTutorial())
					{
						return false;
					}
					return SemiFunc.RunIsLevel();
				}
				catch
				{
					return false;
				}
			}
		}

		internal static int ReserveRoomIndex()
		{
			_nextRoomIndex++;
			return _nextRoomIndex;
		}

		internal static void Register(PocketDimensionCartController controller)
		{
			if (!Controllers.Contains(controller))
			{
				Controllers.Add(controller);
			}
		}

		internal static void Unregister(PocketDimensionCartController controller)
		{
			PocketDimensionCartController controller2 = controller;
			Controllers.Remove(controller2);
			int[] array = (from pair in StoredOwners
				where (Object)(object)pair.Value == (Object)(object)controller2
				select pair.Key).ToArray();
			foreach (int key in array)
			{
				StoredOwners.Remove(key);
			}
		}

		internal static void ResetLevelState()
		{
			Controllers.Clear();
			StoredOwners.Clear();
			AbsorbCooldowns.Clear();
			LocalPhysGrabObjects.Clear();
			_nextRoomIndex = 0;
		}

		internal static bool IsStored(PhysGrabObject physGrabObject)
		{
			int viewId = GetViewId(physGrabObject);
			if (viewId != 0)
			{
				return StoredOwners.ContainsKey(viewId);
			}
			return false;
		}

		internal static bool CanAbsorb(PhysGrabObject physGrabObject)
		{
			int viewId = GetViewId(physGrabObject);
			if (viewId == 0)
			{
				return true;
			}
			if (StoredOwners.ContainsKey(viewId))
			{
				return false;
			}
			if (AbsorbCooldowns.TryGetValue(viewId, out var value) && Time.time < value)
			{
				return false;
			}
			if (AbsorbCooldowns.ContainsKey(viewId))
			{
				AbsorbCooldowns.Remove(viewId);
			}
			return true;
		}

		internal static void MarkStored(PhysGrabObject physGrabObject, PocketDimensionCartController owner)
		{
			int viewId = GetViewId(physGrabObject);
			if (viewId != 0)
			{
				StoredOwners[viewId] = owner;
			}
		}

		internal static void MarkReleased(PhysGrabObject physGrabObject, float cooldown)
		{
			int viewId = GetViewId(physGrabObject);
			if (viewId != 0)
			{
				StoredOwners.Remove(viewId);
				AbsorbCooldowns[viewId] = Time.time + Mathf.Max(0.1f, cooldown);
			}
		}

		internal static PocketDimensionCartController? GetOwner(PhysGrabObject physGrabObject)
		{
			int viewId = GetViewId(physGrabObject);
			if (viewId == 0)
			{
				return null;
			}
			StoredOwners.TryGetValue(viewId, out PocketDimensionCartController value);
			return value;
		}

		internal static PocketDimensionCartController? GetControllerForValueScreen(ValueScreen valueScreen)
		{
			if (!Object.op_Implicit((Object)(object)valueScreen))
			{
				return null;
			}
			foreach (PocketDimensionCartController controller in Controllers)
			{
				if (Object.op_Implicit((Object)(object)controller) && controller.UsesValueScreen(valueScreen))
				{
					return controller;
				}
			}
			return null;
		}

		internal static bool PlayerInsideAnyPocketRoom(PlayerAvatar? player)
		{
			if ((Object)(object)player == (Object)null)
			{
				return false;
			}
			for (int num = Controllers.Count - 1; num >= 0; num--)
			{
				PocketDimensionCartController pocketDimensionCartController = Controllers[num];
				if (!Object.op_Implicit((Object)(object)pocketDimensionCartController))
				{
					Controllers.RemoveAt(num);
				}
				else if (pocketDimensionCartController.PlayerInsidePocketRoom(player))
				{
					return true;
				}
			}
			return false;
		}

		internal static int GetViewId(PhysGrabObject physGrabObject)
		{
			if (!Object.op_Implicit((Object)(object)physGrabObject))
			{
				return 0;
			}
			if (SemiFunc.IsMultiplayer() && Object.op_Implicit((Object)(object)physGrabObject.photonView) && physGrabObject.photonView.ViewID != 0)
			{
				return physGrabObject.photonView.ViewID;
			}
			int instanceID = ((Object)physGrabObject).GetInstanceID();
			int num;
			switch (instanceID)
			{
			case 0:
				return 0;
			default:
				num = -Mathf.Abs(instanceID);
				break;
			case int.MinValue:
				num = instanceID;
				break;
			}
			int num2 = num;
			LocalPhysGrabObjects[num2] = physGrabObject;
			return num2;
		}

		internal static PhysGrabObject? ResolvePhysGrabObject(int viewId)
		{
			if (viewId == 0)
			{
				return null;
			}
			if (viewId < 0)
			{
				if (LocalPhysGrabObjects.TryGetValue(viewId, out PhysGrabObject value) && Object.op_Implicit((Object)(object)value))
				{
					return value;
				}
				LocalPhysGrabObjects.Remove(viewId);
				return null;
			}
			PhotonView val = PhotonView.Find(viewId);
			if (!Object.op_Implicit((Object)(object)val))
			{
				return null;
			}
			return ((Component)val).GetComponent<PhysGrabObject>();
		}

		internal static void TeleportPhysGrabObject(PhysGrabObject physGrabObject, Vector3 position, Quaternion rotation)
		{
			//IL_0056: 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_006d: 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_007b: 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_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			if (Object.op_Implicit((Object)(object)physGrabObject))
			{
				if (SemiFunc.IsMultiplayer() && Object.op_Implicit((Object)(object)physGrabObject.photonView) && physGrabObject.photonView.ViewID != 0)
				{
					physGrabObject.photonView.RPC("SetPositionRPC", (RpcTarget)0, new object[2] { position, rotation });
				}
				else
				{
					physGrabObject.Teleport(position, rotation);
				}
				Rigidbody rb = physGrabObject.rb;
				if (Object.op_Implicit((Object)(object)rb))
				{
					rb.position = position;
					rb.rotation = rotation;
					rb.velocity = Vector3.zero;
					rb.angularVelocity = Vector3.zero;
					rb.WakeUp();
				}
			}
		}

		internal static void ProtectValuable(PhysGrabObject physGrabObject, float seconds)
		{
			if (Object.op_Implicit((Object)(object)physGrabObject))
			{
				PocketDimensionStoredValuable pocketDimensionStoredValuable = ((Component)physGrabObject).GetComponent<PocketDimensionStoredValuable>();
				if (!Object.op_Implicit((Object)(object)pocketDimensionStoredValuable))
				{
					pocketDimensionStoredValuable = ((Component)physGrabObject).gameObject.AddComponent<PocketDimensionStoredValuable>();
				}
				pocketDimensionStoredValuable.Protect(seconds);
			}
		}
	}
}