using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using FishNet;
using FishNet.Broadcast;
using FishNet.Connection;
using FishNet.Object;
using FishNet.Serializing;
using FishNet.Transporting;
using HarmonyLib;
using HowToFishVR.Body;
using HowToFishVR.Input;
using HowToFishVR.Localization;
using HowToFishVR.Net;
using HowToFishVR.Patches;
using HowToFishVR.UI;
using HowToFishVR.VR;
using Microsoft.CodeAnalysis;
using TMPro;
using UnityEngine;
using UnityEngine.EventSystems;
using UnityEngine.Events;
using UnityEngine.InputSystem;
using UnityEngine.InputSystem.Layouts;
using UnityEngine.InputSystem.Users;
using UnityEngine.InputSystem.Utilities;
using UnityEngine.Rendering;
using UnityEngine.Rendering.Universal;
using UnityEngine.SceneManagement;
using UnityEngine.UI;
using UnityEngine.XR;
using UnityEngine.XR.Interaction.Toolkit.UI;
using UnityEngine.XR.Management;
using UnityEngine.XR.OpenXR;
using UnityEngine.XR.OpenXR.Features;
using UnityEngine.XR.OpenXR.Features.Interactions;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("J_axon")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyDescription("HowToFishXR - full 6DoF VR mod for How to Fish")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+e3cc92a1988e2680296bae95a521b7a361bab8be")]
[assembly: AssemblyProduct("HowToFishVR")]
[assembly: AssemblyTitle("HowToFishVR")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[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 HowToFishVR
{
	public enum TurnMode
	{
		Snap,
		Smooth
	}
	public enum BodyMode
	{
		FullBodyIK,
		HandsOnly
	}
	public enum ButtonMode
	{
		Hold,
		Toggle
	}
	public enum DeathView
	{
		FirstPerson,
		ThirdPerson
	}
	public static class VRConfig
	{
		public static ConfigEntry<bool> DisableVR;

		public static ConfigEntry<float> WorldScale;

		public static ConfigEntry<bool> RoomscaleMovement;

		public static ConfigEntry<KeyboardShortcut> RecenterKey;

		public static ConfigEntry<KeyboardShortcut> HeightCalibrateKey;

		public static ConfigEntry<float> SavedEyeHeight;

		public static ConfigEntry<float> SavedHeadCalibY;

		public static ConfigEntry<TurnMode> Turning;

		public static ConfigEntry<int> SnapTurnAngle;

		public static ConfigEntry<float> SmoothTurnSpeed;

		public static ConfigEntry<float> TurnDeadzone;

		public static ConfigEntry<float> MovementDeadzone;

		public static ConfigEntry<bool> HeadRelativeMovement;

		public static ConfigEntry<float> BoatSteerSensitivity;

		public static ConfigEntry<ButtonMode> SprintMode;

		public static ConfigEntry<ButtonMode> CrouchMode;

		public static ConfigEntry<bool> HudFollowsHead;

		public static ConfigEntry<float> HudFollowSmoothing;

		public static ConfigEntry<float> HudScale;

		public static ConfigEntry<float> GripThreshold;

		public static ConfigEntry<bool> RealUIBlur;

		public static ConfigEntry<BodyMode> BodyMode;

		public static ConfigEntry<Vector3> BodyOffset;

		public static ConfigEntry<DeathView> DeathView;

		public static ConfigEntry<bool> MultiplayerVRSync;

		public static ConfigEntry<float> VRSyncRate;

		public static void Init(ConfigFile cfg)
		{
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Expected O, but got Unknown
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: 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_0143: Expected O, but got Unknown
			//IL_0171: Unknown result type (might be due to invalid IL or missing references)
			//IL_017b: Expected O, but got Unknown
			//IL_01a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b3: Expected O, but got Unknown
			//IL_01e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01eb: Expected O, but got Unknown
			//IL_0234: Unknown result type (might be due to invalid IL or missing references)
			//IL_023e: Expected O, but got Unknown
			//IL_02bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c7: Expected O, but got Unknown
			//IL_02f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ff: Expected O, but got Unknown
			//IL_032d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0337: Expected O, but got Unknown
			//IL_038c: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0409: Expected O, but got Unknown
			DisableVR = cfg.Bind<bool>("General", "Disable VR", false, "Start How to Fish in flatscreen mode while keeping the mod installed. Can also be overridden for one launch with the --disable-vr Steam launch option. Restart required.");
			WorldScale = cfg.Bind<float>("General", "World Scale", 1f, new ConfigDescription("Scales your perceived size in the world. 1.0 = default.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.5f, 2f), Array.Empty<object>()));
			RoomscaleMovement = cfg.Bind<bool>("Calibration", "Roomscale Movement", true, "Allow physically walking/crouching to move the in-game body.");
			RecenterKey = cfg.Bind<KeyboardShortcut>("Calibration", "Recenter", new KeyboardShortcut((KeyCode)283, Array.Empty<KeyCode>()), "Re-center the headset forward direction.");
			HeightCalibrateKey = cfg.Bind<KeyboardShortcut>("Calibration", "Calibrate Height", new KeyboardShortcut((KeyCode)284, Array.Empty<KeyCode>()), "Measure and store your standing height / floor level.");
			SavedEyeHeight = cfg.Bind<float>("Calibration", "Saved Eye Height", 0f, "Your calibrated eye height (m) above the player root, saved by F3 and restored on launch so death/respawn/reloads keep it.");
			SavedHeadCalibY = cfg.Bind<float>("Calibration", "Saved Head Reference Height", 0f, "Your calibrated standing head height (m), saved by F3. Informational; the live head reference is re-captured each launch.");
			Turning = cfg.Bind<TurnMode>("Turning", "Turn Mode", TurnMode.Snap, "Snap = instant rotation; Smooth = continuous rotation.");
			SnapTurnAngle = cfg.Bind<int>("Turning", "Snap Angle", 45, new ConfigDescription("Degrees per snap turn.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(15, 90), Array.Empty<object>()));
			SmoothTurnSpeed = cfg.Bind<float>("Turning", "Smooth Speed", 120f, new ConfigDescription("Degrees per second for smooth turning.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(30f, 360f), Array.Empty<object>()));
			TurnDeadzone = cfg.Bind<float>("Turning", "Turn Deadzone", 0.75f, new ConfigDescription("Thumbstick threshold to trigger a snap turn (MAVR-style: must return below 0.35 to re-arm).", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.1f, 0.95f), Array.Empty<object>()));
			MovementDeadzone = cfg.Bind<float>("Locomotion", "Move Deadzone", 0.15f, new ConfigDescription("Thumbstick deadzone for movement.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.05f, 0.5f), Array.Empty<object>()));
			HeadRelativeMovement = cfg.Bind<bool>("Locomotion", "Head Relative Movement", true, "Movement direction follows head gaze (off = follows off-hand controller).");
			BoatSteerSensitivity = cfg.Bind<float>("Locomotion", "Boat Steer Sensitivity", 1f, new ConfigDescription("Multiplier for boat steering from the movement stick.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.3f, 2.5f), Array.Empty<object>()));
			SprintMode = cfg.Bind<ButtonMode>("Locomotion", "Sprint Mode", ButtonMode.Hold, "Left thumbstick click. Hold = sprint while held; Toggle = click to toggle.");
			CrouchMode = cfg.Bind<ButtonMode>("Locomotion", "Crouch Mode", ButtonMode.Toggle, "Right thumbstick click. Toggle = click to toggle (default); Hold = crouch while held.");
			HudFollowsHead = cfg.Bind<bool>("HUD", "HUD Follows Head", true, "HUD rotates with head yaw but stays level (not pitched up/down), floating in front of you.");
			HudFollowSmoothing = cfg.Bind<float>("HUD", "HUD Smoothing", 0.1f, new ConfigDescription("Lower = snappier HUD follow.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.02f, 0.5f), Array.Empty<object>()));
			HudScale = cfg.Bind<float>("HUD", "HUD Scale", 1f, new ConfigDescription("Scale multiplier for the HUD.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.5f, 2f), Array.Empty<object>()));
			GripThreshold = cfg.Bind<float>("Interaction", "Grip Threshold", 0.6f, new ConfigDescription("Grip pull required to grab.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.1f, 0.95f), Array.Empty<object>()));
			RealUIBlur = cfg.Bind<bool>("UI", "Real UI Blur", true, "Keep the game's real frosted-glass pixel-blur on UI panels (the actual UniversalBlurUI effect) instead of a flat dark tint. Turn OFF if panels render black on your headset.");
			BodyMode = cfg.Bind<BodyMode>("Body", "Body Mode", HowToFishVR.BodyMode.FullBodyIK, "FullBodyIK = restored body with VR IK arms that bend naturally. HandsOnly = base game: no body shown, hands only. Snap/smooth turning works in both modes (MAVR-style).");
			BodyOffset = cfg.Bind<Vector3>("Body", "Body Offset", new Vector3(0f, 0f, -0.2f), "x, y, z nudge for the whole body in body space, metres. Positive z is forward. Default sits it 20cm back so you are not inside your own collar.");
			DeathView = cfg.Bind<DeathView>("Death", "Death View", HowToFishVR.DeathView.FirstPerson, "FirstPerson = camera stays on the ragdoll's head (free head-look, head model hidden). ThirdPerson = the game's default third-person orbit around your body, head-tracked for VR.");
			MultiplayerVRSync = cfg.Bind<bool>("Multiplayer", "VR Pose Sync", true, "VR players broadcast their full-body poses (head, arms, hands, feet, body yaw) and every modded client — VR or flatscreen — applies them to remote players, so everyone sees VR players exactly as they see themselves (one-hand/two-hand grips included). Head look already syncs via the base game. Flatscreen modded players receive the same syncing as VR players; vanilla hosts are unaffected.");
			VRSyncRate = cfg.Bind<float>("Multiplayer", "VR Pose Sync Rate", 60f, new ConfigDescription("Pose broadcast rate in Hz (5-60). MAVR-class smoothness is 60 Hz — higher = smoother but more bandwidth.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(5f, 60f), Array.Empty<object>()));
		}
	}
	public static class Entrypoint
	{
		public static void Initialize()
		{
			VRActions.Initialize();
			if (Plugin.VRRequested)
			{
				Plugin.VREnabled = OpenXRBoot.Start();
			}
			try
			{
				Loc.Register();
			}
			catch
			{
			}
			try
			{
				VRNetSync.Create();
				RemoteBodyDriver.Create();
				ApplyNetPatches();
			}
			catch (Exception arg)
			{
				Plugin.Logger.LogError((object)$"VR networking failed to initialize: {arg}");
			}
			if (Plugin.VREnabled)
			{
				VRRig.Create();
				VRCameraPoser.Create();
				VRDesktopMirror.Create();
				VRCalibration.Create();
				VRDamageOverlay.Create();
				VRUIManager.Create();
				VRLaser.Create();
				VRSettingsPanel.Create();
				VRHeldItem.Create();
				BodyLifecycle.Create();
				BlurCapture.Create();
				ApplyPatchesResiliently();
			}
		}

		private static void ApplyPatchesResiliently()
		{
			Type[] types = typeof(Plugin).Assembly.GetTypes();
			foreach (Type type in types)
			{
				if (type.GetCustomAttributes(typeof(HarmonyPatch), inherit: true).Any() && !type.GetCustomAttributes(typeof(NetOnlyPatchAttribute), inherit: true).Any())
				{
					try
					{
						Plugin.HarmonyInstance.CreateClassProcessor(type).Patch();
					}
					catch (Exception ex)
					{
						Plugin.Logger.LogError((object)("Patch class '" + type.Name + "' failed: " + ex.Message));
					}
				}
			}
		}

		private static void ApplyNetPatches()
		{
			Type[] types = typeof(Plugin).Assembly.GetTypes();
			foreach (Type type in types)
			{
				if (type.GetCustomAttributes(typeof(NetOnlyPatchAttribute), inherit: true).Any())
				{
					try
					{
						Plugin.HarmonyInstance.CreateClassProcessor(type).Patch();
					}
					catch (Exception ex)
					{
						Plugin.Logger.LogError((object)("Net patch class '" + type.Name + "' failed: " + ex.Message));
					}
				}
			}
		}
	}
	[BepInPlugin("com.jaxon.howtofishvr", "HowToFishXR", "1.0.0")]
	[BepInProcess("How to Fish.exe")]
	public class Plugin : BaseUnityPlugin
	{
		public const string Guid = "com.jaxon.howtofishvr";

		public const string Name = "HowToFishXR";

		public const string Version = "1.0.0";

		public static Plugin Instance { get; private set; }

		public static ManualLogSource Logger { get; private set; }

		public static Harmony HarmonyInstance { get; private set; }

		public static bool VREnabled { get; internal set; }

		public static bool HeadsetActive
		{
			get
			{
				//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)
				if (!VREnabled)
				{
					return false;
				}
				try
				{
					if (!XRSettings.isDeviceActive)
					{
						return false;
					}
					InputDevice deviceAtXRNode = InputDevices.GetDeviceAtXRNode((XRNode)2);
					return ((InputDevice)(ref deviceAtXRNode)).isValid;
				}
				catch
				{
					return VREnabled;
				}
			}
		}

		public static bool VRRequested { get; private set; }

		private void Awake()
		{
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Expected O, but got Unknown
			Instance = this;
			Logger = ((BaseUnityPlugin)this).Logger;
			Application.runInBackground = true;
			ResolveBundledAssemblies();
			VRConfig.Init(((BaseUnityPlugin)this).Config);
			VRRequested = ResolveVRRequested();
			HarmonyInstance = new Harmony("com.jaxon.howtofishvr");
			try
			{
				Entrypoint.Initialize();
			}
			catch (Exception arg)
			{
				Logger.LogError((object)$"Fatal error during VR initialization: {arg}");
			}
		}

		private bool ResolveVRRequested()
		{
			bool flag = Environment.GetCommandLineArgs().Contains<string>("--disable-vr", StringComparer.OrdinalIgnoreCase);
			return !(VRConfig.DisableVR.Value || flag);
		}

		private void ResolveBundledAssemblies()
		{
			string here = Path.GetDirectoryName(((BaseUnityPlugin)this).Info.Location);
			AppDomain.CurrentDomain.AssemblyResolve += delegate(object _, ResolveEventArgs args)
			{
				string text = new AssemblyName(args.Name).Name + ".dll";
				string text2 = Path.Combine(here, text);
				if (File.Exists(text2))
				{
					try
					{
						return Assembly.LoadFrom(text2);
					}
					catch
					{
					}
				}
				string text3 = Path.Combine(here, "RuntimeDeps", text);
				if (File.Exists(text3))
				{
					try
					{
						return Assembly.LoadFrom(text3);
					}
					catch
					{
					}
				}
				return (Assembly)null;
			};
		}
	}
}
namespace HowToFishVR.VR
{
	internal sealed class BlurCapture : MonoBehaviour
	{
		private int _globalId;

		private RenderTexture _rt;

		private bool _haveContent;

		internal static BlurCapture Instance { get; private set; }

		internal bool HasBlur
		{
			get
			{
				if (_haveContent && (Object)(object)_rt != (Object)null)
				{
					return _rt.IsCreated();
				}
				return false;
			}
		}

		internal static void Create()
		{
			//IL_0013: 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_001e: Expected O, but got Unknown
			if (!((Object)(object)Instance != (Object)null))
			{
				GameObject val = new GameObject("HowToFishVR BlurCapture");
				Object.DontDestroyOnLoad((Object)val);
				Instance = val.AddComponent<BlurCapture>();
			}
		}

		private void Awake()
		{
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			_globalId = Shader.PropertyToID("_GlobalUniversalBlurTexture");
			int w = Mathf.Max(2, Screen.width / 2);
			int h = Mathf.Max(2, Screen.height / 2);
			EnsureRT(w, h);
			ClearRT(new Color(0.1f, 0.13f, 0.16f, 1f));
		}

		private void OnEnable()
		{
			RenderPipelineManager.endCameraRendering += OnEndCamera;
		}

		private void OnDisable()
		{
			RenderPipelineManager.endCameraRendering -= OnEndCamera;
		}

		private void Update()
		{
			if ((Object)(object)_rt != (Object)null && _rt.IsCreated())
			{
				Shader.SetGlobalTexture(_globalId, (Texture)(object)_rt);
			}
		}

		private void OnEndCamera(ScriptableRenderContext ctx, Camera cam)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Invalid comparison between Unknown and I4
			try
			{
				if ((Object)(object)cam == (Object)null || (int)cam.cameraType != 1)
				{
					return;
				}
				Texture globalTexture = Shader.GetGlobalTexture(_globalId);
				RenderTexture val = (RenderTexture)(object)((globalTexture is RenderTexture) ? globalTexture : null);
				if (!((Object)(object)val == (Object)null) && !((Object)(object)val == (Object)(object)_rt) && val.IsCreated())
				{
					EnsureRT(((Texture)val).width, ((Texture)val).height);
					if (!((Object)(object)_rt == (Object)null))
					{
						Graphics.Blit((Texture)(object)val, _rt);
						_haveContent = true;
					}
				}
			}
			catch
			{
			}
		}

		private void EnsureRT(int w, int h)
		{
			//IL_0065: 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_0075: 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_0083: 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_0096: Expected O, but got Unknown
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			if (w < 2 || h < 2 || ((Object)(object)_rt != (Object)null && ((Texture)_rt).width == w && ((Texture)_rt).height == h && _rt.IsCreated()))
			{
				return;
			}
			if ((Object)(object)_rt != (Object)null)
			{
				try
				{
					_rt.Release();
				}
				catch
				{
				}
			}
			_rt = new RenderTexture(w, h, 0, (RenderTextureFormat)9)
			{
				name = "HowToFishVR_BlurCapture",
				useMipMap = false,
				autoGenerateMips = false,
				filterMode = (FilterMode)1,
				wrapMode = (TextureWrapMode)1
			};
			try
			{
				_rt.Create();
			}
			catch
			{
			}
			ClearRT(new Color(0.1f, 0.13f, 0.16f, 1f));
		}

		private void ClearRT(Color c)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_rt == (Object)null || !_rt.IsCreated())
			{
				return;
			}
			RenderTexture active = RenderTexture.active;
			try
			{
				RenderTexture.active = _rt;
				GL.Clear(true, true, c);
			}
			catch
			{
			}
			finally
			{
				RenderTexture.active = active;
			}
		}

		private void OnDestroy()
		{
			if ((Object)(object)_rt != (Object)null)
			{
				try
				{
					_rt.Release();
				}
				catch
				{
				}
				_rt = null;
			}
			if ((Object)(object)Instance == (Object)(object)this)
			{
				Instance = null;
			}
		}
	}
	public static class OpenXRBoot
	{
		private static XRGeneralSettings _general;

		private static XRManagerSettings _manager;

		private static OpenXRLoader _loader;

		public static bool Running { get; private set; }

		public static bool Start()
		{
			try
			{
				NeutralizeAnalytics();
				BuildSettings();
				if (!VerifySubsystemManifest())
				{
					Plugin.Logger.LogError((object)"OpenXR subsystem descriptors not found. The native UnityOpenXR plugin / manifest was not staged into How to Fish_Data. Check the preloader ran.");
					return false;
				}
				if (!InitAndStart())
				{
					Plugin.Logger.LogError((object)"OpenXR loader failed to produce a display subsystem. Is a headset connected and an OpenXR runtime active (SteamVR/Oculus/VD)?");
					return false;
				}
				try
				{
					InputSystem.settings.backgroundBehavior = (BackgroundBehavior)2;
				}
				catch
				{
				}
				XRSettings.eyeTextureResolutionScale = 1f;
				SetFloorTrackingOrigin();
				Running = true;
				return true;
			}
			catch (Exception arg)
			{
				Plugin.Logger.LogError((object)$"Exception while starting OpenXR: {arg}");
				return false;
			}
		}

		public static void Stop()
		{
			if (!Running)
			{
				return;
			}
			try
			{
				XRManagerSettings manager = _manager;
				if (manager != null)
				{
					manager.StopSubsystems();
				}
				XRManagerSettings manager2 = _manager;
				if (manager2 != null)
				{
					manager2.DeinitializeLoader();
				}
			}
			catch
			{
			}
			Running = false;
		}

		private static void NeutralizeAnalytics()
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Expected O, but got Unknown
			Type type = AccessTools.TypeByName("UnityEngine.XR.OpenXR.OpenXRAnalytics");
			if (type == null)
			{
				return;
			}
			HarmonyMethod val = new HarmonyMethod(AccessTools.Method(typeof(OpenXRBoot), "SkipOriginal", (Type[])null, (Type[])null));
			MethodInfo[] methods = type.GetMethods(BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
			foreach (MethodInfo methodInfo in methods)
			{
				if (!(methodInfo.DeclaringType != type) && !methodInfo.IsAbstract && !methodInfo.ContainsGenericParameters)
				{
					try
					{
						Plugin.HarmonyInstance.Patch((MethodBase)methodInfo, val, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
					}
					catch
					{
					}
				}
			}
		}

		private static bool SkipOriginal()
		{
			return false;
		}

		private static void BuildSettings()
		{
			if (_general == null)
			{
				_general = ScriptableObject.CreateInstance<XRGeneralSettings>();
			}
			if (_manager == null)
			{
				_manager = ScriptableObject.CreateInstance<XRManagerSettings>();
			}
			if (_loader == null)
			{
				_loader = ScriptableObject.CreateInstance<OpenXRLoader>();
			}
			Traverse.Create((object)_general).Property("Manager", (object[])null).SetValue((object)_manager);
			SetActiveLoaders(_manager, new List<XRLoader> { (XRLoader)(object)_loader });
			_manager.automaticLoading = false;
			_manager.automaticRunning = false;
			TrySetXRGeneralSettingsInstance(_general);
			ConfigureOpenXRSettings();
		}

		private static void ConfigureOpenXRSettings()
		{
			OpenXRSettings val = OpenXRSettings.Instance;
			if ((Object)(object)val == (Object)null)
			{
				val = ScriptableObject.CreateInstance<OpenXRSettings>();
				(AccessTools.Field(typeof(OpenXRSettings), "s_RuntimeSettingsInstance") ?? AccessTools.Field(typeof(OpenXRSettings), "s_Instance") ?? AccessTools.Field(typeof(OpenXRSettings), "m_Instance"))?.SetValue(null, val);
			}
			try
			{
				val.renderMode = (RenderMode)0;
			}
			catch
			{
			}
			try
			{
				val.depthSubmissionMode = (DepthSubmissionMode)0;
			}
			catch
			{
			}
			OpenXRFeature[] features = BuildInteractionFeatures();
			SetFeatures(val, features);
		}

		private static OpenXRFeature[] BuildInteractionFeatures()
		{
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Expected O, but got Unknown
			Type[] obj = new Type[8]
			{
				typeof(OculusTouchControllerProfile),
				typeof(MetaQuestTouchPlusControllerProfile),
				typeof(MetaQuestTouchProControllerProfile),
				typeof(ValveIndexControllerProfile),
				typeof(HTCViveControllerProfile),
				typeof(MicrosoftMotionControllerProfile),
				typeof(HPReverbG2ControllerProfile),
				typeof(KHRSimpleControllerProfile)
			};
			List<OpenXRFeature> list = new List<OpenXRFeature>();
			Type[] array = obj;
			foreach (Type type in array)
			{
				try
				{
					if (typeof(OpenXRFeature).IsAssignableFrom(type))
					{
						OpenXRFeature val = (OpenXRFeature)ScriptableObject.CreateInstance(type);
						Traverse.Create((object)val).Property("enabled", (object[])null).SetValue((object)true);
						list.Add(val);
					}
				}
				catch
				{
				}
			}
			if (list.Count == 0)
			{
				Plugin.Logger.LogError((object)"OpenXR started without any controller interaction profiles; motion-controller input will not work.");
			}
			return list.ToArray();
		}

		private static bool InitAndStart()
		{
			TrySetXRGeneralSettingsInstance(_general);
			AccessTools.Field(typeof(XRGeneralSettings), "m_InitManagerOnStart")?.SetValue(_general, true);
			Environment.SetEnvironmentVariable("XR_RUNTIME_JSON", null);
			InvokePrivate(_general, "InitXRSDK");
			InvokePrivate(_general, "Start");
			List<XRDisplaySubsystem> list = new List<XRDisplaySubsystem>();
			SubsystemManager.GetSubsystems<XRDisplaySubsystem>(list);
			return list.Count > 0;
		}

		private static void InvokePrivate(object target, string method)
		{
			try
			{
				MethodInfo methodInfo = AccessTools.Method(target.GetType(), method, (Type[])null, (Type[])null);
				if (!(methodInfo == null))
				{
					methodInfo.Invoke(target, null);
				}
			}
			catch
			{
			}
		}

		private static void SetFloorTrackingOrigin()
		{
			try
			{
				List<XRInputSubsystem> list = new List<XRInputSubsystem>();
				SubsystemManager.GetSubsystems<XRInputSubsystem>(list);
				foreach (XRInputSubsystem item in list)
				{
					if (item.TrySetTrackingOriginMode((TrackingOriginModeFlags)2))
					{
						item.TryRecenter();
					}
				}
			}
			catch
			{
			}
		}

		private static bool VerifySubsystemManifest()
		{
			List<ISubsystemDescriptor> list = new List<ISubsystemDescriptor>();
			SubsystemManager.GetAllSubsystemDescriptors(list);
			List<string> source = list.Select((ISubsystemDescriptor d) => d.id).ToList();
			if (source.Any((string id) => id.Contains("OpenXR Display")))
			{
				return source.Any((string id) => id.Contains("OpenXR Input"));
			}
			return false;
		}

		private static void SetActiveLoaders(XRManagerSettings manager, List<XRLoader> loaders)
		{
			try
			{
				if (manager.activeLoaders is List<XRLoader> list)
				{
					list.Clear();
					list.AddRange(loaders);
					return;
				}
			}
			catch
			{
			}
			AccessTools.Field(typeof(XRManagerSettings), "m_Loaders")?.SetValue(manager, loaders);
		}

		private static void TrySetXRGeneralSettingsInstance(XRGeneralSettings general)
		{
			(AccessTools.Field(typeof(XRGeneralSettings), "s_RuntimeSettingsInstance") ?? AccessTools.Field(typeof(XRGeneralSettings), "s_Instance") ?? AccessTools.Field(typeof(XRGeneralSettings), "k_SettingsInstance"))?.SetValue(null, general);
		}

		private static void SetFeatures(OpenXRSettings settings, OpenXRFeature[] features)
		{
			PropertyInfo propertyInfo = AccessTools.Property(typeof(OpenXRSettings), "features");
			if (propertyInfo != null && propertyInfo.CanWrite)
			{
				propertyInfo.SetValue(settings, features);
			}
			else
			{
				(AccessTools.Field(typeof(OpenXRSettings), "features") ?? AccessTools.Field(typeof(OpenXRSettings), "m_features") ?? AccessTools.Field(typeof(OpenXRSettings), "featureSets"))?.SetValue(settings, features);
			}
		}
	}
	public class VRCalibration : MonoBehaviour
	{
		private enum State
		{
			Idle,
			Prompt,
			Countdown,
			Done
		}

		private bool _f3WasDown;

		private State _state;

		private float _timer;

		private int _count;

		private Canvas _canvas;

		private Text _text;

		public static VRCalibration Instance { get; private set; }

		public static void Create()
		{
			//IL_0013: 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_001e: Expected O, but got Unknown
			if (!((Object)(object)Instance != (Object)null))
			{
				GameObject val = new GameObject("HowToFishVR Calibration");
				Object.DontDestroyOnLoad((Object)val);
				Instance = val.AddComponent<VRCalibration>();
				Instance.BuildUI();
			}
		}

		public void Begin()
		{
			if (_state == State.Idle)
			{
				_state = State.Prompt;
				_timer = 0f;
			}
		}

		private void BuildUI()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Expected O, but got Unknown
			//IL_004e: 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_005e: 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_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Expected O, but got Unknown
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_010d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0117: 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_0122: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("Calibration Canvas");
			val.transform.SetParent(((Component)this).transform, false);
			val.layer = 5;
			_canvas = val.AddComponent<Canvas>();
			_canvas.renderMode = (RenderMode)2;
			val.AddComponent<CanvasScaler>();
			RectTransform val2 = (RectTransform)((Component)_canvas).transform;
			val2.sizeDelta = new Vector2(800f, 300f);
			((Transform)val2).localScale = Vector3.one * 0.0015f;
			GameObject val3 = new GameObject("Text");
			val3.transform.SetParent(val.transform, false);
			val3.layer = 5;
			_text = val3.AddComponent<Text>();
			_text.font = FindFont();
			_text.fontSize = 48;
			_text.alignment = (TextAnchor)4;
			((Graphic)_text).color = Color.white;
			_text.horizontalOverflow = (HorizontalWrapMode)0;
			RectTransform val4 = (RectTransform)((Component)_text).transform;
			val4.anchorMin = Vector2.zero;
			val4.anchorMax = Vector2.one;
			val4.offsetMin = Vector2.zero;
			val4.offsetMax = Vector2.zero;
			val.SetActive(false);
		}

		private static Font FindFont()
		{
			try
			{
				Font builtinResource = Resources.GetBuiltinResource<Font>("LegacyRuntime.ttf");
				if ((Object)(object)builtinResource != (Object)null)
				{
					return builtinResource;
				}
			}
			catch
			{
			}
			try
			{
				Font val = Font.CreateDynamicFontFromOSFont("Arial", 48);
				if ((Object)(object)val != (Object)null)
				{
					return val;
				}
			}
			catch
			{
			}
			try
			{
				Font val2 = Font.CreateDynamicFontFromOSFont("Segoe UI", 48);
				if ((Object)(object)val2 != (Object)null)
				{
					return val2;
				}
			}
			catch
			{
			}
			return null;
		}

		private void Update()
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: 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_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: 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_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: Unknown result type (might be due to invalid IL or missing references)
			//IL_0117: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_011e: Unknown result type (might be due to invalid IL or missing references)
			if (!Plugin.VREnabled)
			{
				return;
			}
			bool flag = false;
			try
			{
				KeyboardShortcut value = VRConfig.HeightCalibrateKey.Value;
				flag = ((KeyboardShortcut)(ref value)).IsDown();
			}
			catch
			{
			}
			try
			{
				if (Input.GetKey((KeyCode)284))
				{
					flag = true;
				}
			}
			catch
			{
			}
			if (flag && !_f3WasDown && _state == State.Idle)
			{
				Begin();
			}
			_f3WasDown = flag;
			VRRig instance = VRRig.Instance;
			if ((Object)(object)instance == (Object)null || (Object)(object)instance.Head == (Object)null)
			{
				return;
			}
			bool flag2 = _state != State.Idle;
			if ((Object)(object)_canvas != (Object)null && ((Component)_canvas).gameObject.activeSelf != flag2)
			{
				((Component)_canvas).gameObject.SetActive(flag2);
			}
			if (!flag2)
			{
				return;
			}
			Transform head = instance.Head;
			Vector3 forward = head.forward;
			forward.y = 0f;
			if (((Vector3)(ref forward)).sqrMagnitude > 0.0001f)
			{
				((Vector3)(ref forward)).Normalize();
				((Component)_canvas).transform.position = head.position + forward * 1.2f;
				((Component)_canvas).transform.rotation = Quaternion.LookRotation(forward, Vector3.up);
			}
			switch (_state)
			{
			case State.Prompt:
				_text.text = "Stand up straight and hold a T-pose\n(arms straight out to the sides)";
				if (IsTPose(instance))
				{
					_timer += Time.deltaTime;
					if (_timer >= 0.5f)
					{
						_state = State.Countdown;
						_count = 3;
						_timer = 0f;
					}
				}
				else
				{
					_timer = 0f;
				}
				break;
			case State.Countdown:
				if (!IsTPose(instance))
				{
					_state = State.Prompt;
					_timer = 0f;
					break;
				}
				_text.text = $"Hold still...\n{_count}";
				_timer += Time.deltaTime;
				if (_timer >= 1f)
				{
					_timer = 0f;
					_count--;
					if (_count <= 0)
					{
						instance.CalibrateNow();
						_state = State.Done;
						_text.text = "Calibrated!";
						Pulse();
					}
				}
				break;
			case State.Done:
				_timer += Time.deltaTime;
				if (_timer >= 1.5f)
				{
					_state = State.Idle;
					_timer = 0f;
				}
				break;
			}
		}

		private static void Pulse()
		{
			//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_0008: 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)
			try
			{
				InputDevice deviceAtXRNode = InputDevices.GetDeviceAtXRNode((XRNode)4);
				InputDevice deviceAtXRNode2 = InputDevices.GetDeviceAtXRNode((XRNode)5);
				if (((InputDevice)(ref deviceAtXRNode)).isValid)
				{
					((InputDevice)(ref deviceAtXRNode)).SendHapticImpulse(0u, 0.6f, 0.25f);
				}
				if (((InputDevice)(ref deviceAtXRNode2)).isValid)
				{
					((InputDevice)(ref deviceAtXRNode2)).SendHapticImpulse(0u, 0.6f, 0.25f);
				}
			}
			catch
			{
			}
		}

		private static bool IsTPose(VRRig rig)
		{
			//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_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_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_0024: 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_003d: 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_005b: 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_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: 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_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			Vector3 position = rig.Head.position;
			Vector3 position2 = rig.LeftHand.position;
			Vector3 position3 = rig.RightHand.position;
			bool num = Mathf.Abs(position2.y - position.y) < 0.45f && Mathf.Abs(position3.y - position.y) < 0.45f;
			Vector3 val = default(Vector3);
			((Vector3)(ref val))..ctor(position2.x - position.x, 0f, position2.z - position.z);
			Vector3 val2 = default(Vector3);
			((Vector3)(ref val2))..ctor(position3.x - position.x, 0f, position3.z - position.z);
			bool flag = ((Vector3)(ref val)).magnitude > 0.35f && ((Vector3)(ref val2)).magnitude > 0.35f;
			bool flag2 = Vector3.Dot(((Vector3)(ref val)).normalized, ((Vector3)(ref val2)).normalized) < -0.3f;
			return num && flag && flag2;
		}
	}
	public static class VRCameraPoser
	{
		public static VRCameraPoser_Behaviour Instance;

		public static void Create()
		{
			//IL_0013: 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_001e: Expected O, but got Unknown
			if (!((Object)(object)Instance != (Object)null))
			{
				GameObject val = new GameObject("HowToFishVR CameraPoser");
				Object.DontDestroyOnLoad((Object)val);
				Instance = val.AddComponent<VRCameraPoser_Behaviour>();
			}
		}
	}
	public class VRCameraPoser_Behaviour : MonoBehaviour
	{
		private static Transform _deadHead;

		private static Vector3 _deadHeadScale = Vector3.one;

		private static bool _deadHeadHidden;

		private static SelfDrivingBoat _menuBoat;

		private static Transform _menuCameraTarget;

		private static Vector3 _menuTargetLocalOffset;

		private static bool _menuAnchorInit;

		private static bool _customizationPoseActive;

		private static SelfDrivingBoat _customizationBoat;

		private static float _customizationNeutralHeadYaw;

		private static float _customizationStartTurnYaw;

		private static bool TryGetRagdollHead(out Vector3 pos)
		{
			//IL_0001: 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_007d: 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_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_0063: 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)
			pos = default(Vector3);
			try
			{
				Player localPlayer = Player.LocalPlayer;
				if ((Object)(object)localPlayer == (Object)null || (Object)(object)localPlayer.Dying == (Object)null || !localPlayer.Dying.IsDead)
				{
					return false;
				}
				DeadPlayer deadPlayer = localPlayer.Dying.DeadPlayer;
				if ((Object)(object)deadPlayer == (Object)null)
				{
					return false;
				}
				if ((Object)(object)deadPlayer._mouthUpper != (Object)null)
				{
					pos = deadPlayer._mouthUpper.position;
					return true;
				}
				pos = ((Component)deadPlayer).transform.position + Vector3.up * 0.2f;
				return true;
			}
			catch
			{
				return false;
			}
		}

		private static void HideDeadHead()
		{
			//IL_00a8: 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)
			try
			{
				if (_deadHeadHidden && (Object)(object)_deadHead != (Object)null)
				{
					return;
				}
				if ((Object)(object)_deadHead == (Object)null)
				{
					Player localPlayer = Player.LocalPlayer;
					if ((Object)(object)localPlayer == (Object)null || (Object)(object)localPlayer.Dying == (Object)null || (Object)(object)localPlayer.Dying.DeadPlayer == (Object)null)
					{
						return;
					}
					_deadHead = FindHeadBone(((Component)localPlayer.Dying.DeadPlayer).transform);
					if ((Object)(object)_deadHead == (Object)null)
					{
						_deadHeadHidden = true;
						return;
					}
					_deadHeadScale = _deadHead.localScale;
				}
				if ((Object)(object)_deadHead != (Object)null)
				{
					_deadHead.localScale = Vector3.zero;
				}
				_deadHeadHidden = true;
			}
			catch
			{
			}
		}

		private static void RestoreDeadHead()
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_deadHead != (Object)null && _deadHeadHidden)
			{
				_deadHead.localScale = _deadHeadScale;
			}
			_deadHead = null;
			_deadHeadHidden = false;
		}

		private static Transform FindHeadBone(Transform root)
		{
			if ((Object)(object)root == (Object)null)
			{
				return null;
			}
			Transform[] componentsInChildren = ((Component)root).GetComponentsInChildren<Transform>(true);
			foreach (Transform val in componentsInChildren)
			{
				if (!((Object)(object)val == (Object)null) && ((Object)val).name != null)
				{
					string name = ((Object)val).name;
					if (name.IndexOf("Head", StringComparison.OrdinalIgnoreCase) >= 0 && name.IndexOf("Holder", StringComparison.OrdinalIgnoreCase) < 0 && name.IndexOf("hold", StringComparison.OrdinalIgnoreCase) < 0 && name.IndexOf("mouth", StringComparison.OrdinalIgnoreCase) < 0 && name.IndexOf("hair", StringComparison.OrdinalIgnoreCase) < 0)
					{
						return val;
					}
				}
			}
			return null;
		}

		private static Vector3 MenuBoatAnchor(Camera primary)
		{
			//IL_0006: 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_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: 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_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: 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_00da: 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_0109: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: 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_00fe: 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)
			SelfDrivingBoat val = null;
			Transform val2 = null;
			Vector3 val3 = default(Vector3);
			try
			{
				MainMenuManager instance = MainMenuManager._instance;
				if ((Object)(object)instance != (Object)null)
				{
					val = instance._boat;
				}
				if ((Object)(object)val != (Object)null)
				{
					bool isInSkinCustomization = LocalSkin.IsInSkinCustomization;
					val2 = (isInSkinCustomization ? val._skinCustomizationPos : val._defaultCamPos);
					if ((Object)(object)val2 == (Object)null)
					{
						val2 = ((Component)val).transform;
					}
					val3 = val2.position;
					val3.y = (isInSkinCustomization ? val._skinCustomizationHeight : val._defaultHeight);
				}
			}
			catch
			{
			}
			if ((Object)(object)val == (Object)null || (Object)(object)val2 == (Object)null)
			{
				return ((Component)primary).transform.position;
			}
			if (!_menuAnchorInit || (Object)(object)_menuBoat != (Object)(object)val)
			{
				_menuBoat = val;
				if (!LocalSkin.IsInSkinCustomization)
				{
					_menuTargetLocalOffset = Quaternion.Inverse(val2.rotation) * (((Component)primary).transform.position - val3);
				}
				_menuAnchorInit = true;
			}
			_menuCameraTarget = val2;
			if (!LocalSkin.IsInSkinCustomization)
			{
				return val3 + val2.rotation * _menuTargetLocalOffset;
			}
			return val3;
		}

		internal static bool TryGetCustomizationOrigin(Quaternion headRotation, float turnYaw, out Quaternion origin)
		{
			//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_0095: 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_00b5: 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_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: 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_00f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: 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_0132: 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)
			origin = Quaternion.identity;
			try
			{
				if (!MainMenuManager.IsInMenu || !LocalSkin.IsInSkinCustomization)
				{
					_customizationPoseActive = false;
					_customizationBoat = null;
					return false;
				}
				MainMenuManager instance = MainMenuManager._instance;
				SelfDrivingBoat val = (((Object)(object)instance != (Object)null) ? instance._boat : null);
				if ((Object)(object)val == (Object)null || (Object)(object)val._skinCustomizationPos == (Object)null || (Object)(object)val._skinCustomizationLookAt == (Object)null)
				{
					return false;
				}
				if (!_customizationPoseActive || (Object)(object)_customizationBoat != (Object)(object)val)
				{
					_customizationPoseActive = true;
					_customizationBoat = val;
					_customizationNeutralHeadYaw = ((Quaternion)(ref headRotation)).eulerAngles.y;
					_customizationStartTurnYaw = turnYaw;
				}
				Vector3 position = val._skinCustomizationPos.position;
				position.y = val._skinCustomizationHeight;
				Vector3 val2 = val._skinCustomizationLookAt.position - position;
				val2.y = 0f;
				if (((Vector3)(ref val2)).sqrMagnitude < 1E-06f)
				{
					return false;
				}
				Quaternion val3 = Quaternion.LookRotation(val2, Vector3.up);
				float y = ((Quaternion)(ref val3)).eulerAngles.y;
				float num = Mathf.DeltaAngle(_customizationStartTurnYaw, turnYaw);
				origin = Quaternion.Euler(0f, y - _customizationNeutralHeadYaw + num, 0f);
				return true;
			}
			catch
			{
				return false;
			}
		}

		private static void ClearTp()
		{
			_menuAnchorInit = false;
			_menuBoat = null;
			_menuCameraTarget = null;
			_customizationPoseActive = false;
			_customizationBoat = null;
		}

		private void OnEnable()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Expected O, but got Unknown
			Application.onBeforeRender += new UnityAction(Pose);
		}

		private void OnDisable()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Expected O, but got Unknown
			Application.onBeforeRender -= new UnityAction(Pose);
		}

		public void Recalibrate()
		{
		}

		private void Pose()
		{
			//IL_0225: Unknown result type (might be due to invalid IL or missing references)
			//IL_0227: Unknown result type (might be due to invalid IL or missing references)
			//IL_0231: Unknown result type (might be due to invalid IL or missing references)
			//IL_0236: Unknown result type (might be due to invalid IL or missing references)
			//IL_023b: 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_023f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0240: Unknown result type (might be due to invalid IL or missing references)
			//IL_0245: Unknown result type (might be due to invalid IL or missing references)
			//IL_0249: Unknown result type (might be due to invalid IL or missing references)
			//IL_024e: 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_00ac: 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_0267: Unknown result type (might be due to invalid IL or missing references)
			//IL_025e: 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_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0283: Unknown result type (might be due to invalid IL or missing references)
			//IL_028f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0294: Unknown result type (might be due to invalid IL or missing references)
			//IL_029d: 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_02a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ae: 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_02b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_02be: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c7: 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)
			//IL_02ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d6: 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_0114: Unknown result type (might be due to invalid IL or missing references)
			//IL_0308: Unknown result type (might be due to invalid IL or missing references)
			//IL_0316: Unknown result type (might be due to invalid IL or missing references)
			//IL_0318: Unknown result type (might be due to invalid IL or missing references)
			//IL_0319: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_043c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0441: Unknown result type (might be due to invalid IL or missing references)
			//IL_0449: Unknown result type (might be due to invalid IL or missing references)
			//IL_044b: Unknown result type (might be due to invalid IL or missing references)
			//IL_044d: Unknown result type (might be due to invalid IL or missing references)
			//IL_044f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0454: Unknown result type (might be due to invalid IL or missing references)
			//IL_046c: Unknown result type (might be due to invalid IL or missing references)
			//IL_046e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0470: Unknown result type (might be due to invalid IL or missing references)
			//IL_0471: Unknown result type (might be due to invalid IL or missing references)
			//IL_0473: Unknown result type (might be due to invalid IL or missing references)
			//IL_0478: Unknown result type (might be due to invalid IL or missing references)
			//IL_047d: Unknown result type (might be due to invalid IL or missing references)
			//IL_048e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0490: Unknown result type (might be due to invalid IL or missing references)
			//IL_0491: 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_0045: 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_0053: 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_005b: 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_0366: Unknown result type (might be due to invalid IL or missing references)
			//IL_0367: Unknown result type (might be due to invalid IL or missing references)
			//IL_0378: Unknown result type (might be due to invalid IL or missing references)
			//IL_037a: Unknown result type (might be due to invalid IL or missing references)
			//IL_037b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0334: Unknown result type (might be due to invalid IL or missing references)
			//IL_0342: Unknown result type (might be due to invalid IL or missing references)
			//IL_0344: Unknown result type (might be due to invalid IL or missing references)
			//IL_0345: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c4: 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_021e: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if (!Plugin.HeadsetActive)
				{
					return;
				}
				VRActions instance = VRActions.Instance;
				VRRig instance2 = VRRig.Instance;
				if (instance == null || (Object)(object)instance2 == (Object)null || (Object)(object)instance2.Root == (Object)null || !instance2.IsCalibrated)
				{
					return;
				}
				Vector3 headPos = instance.HeadPos;
				Quaternion headRot = instance.HeadRot;
				Quaternion rotation = instance2.Root.rotation;
				Vector3 headCalib = instance2.HeadCalib;
				Camera val = null;
				try
				{
					Player localPlayer = Player.LocalPlayer;
					if ((Object)(object)localPlayer != (Object)null && (Object)(object)localPlayer.Camera != (Object)null)
					{
						val = localPlayer.Camera.Cam;
					}
				}
				catch
				{
				}
				if ((Object)(object)instance2.Head != (Object)null)
				{
					instance2.Head.localPosition = headPos;
					instance2.Head.localRotation = headRot;
				}
				if ((Object)(object)instance2.LeftHand != (Object)null)
				{
					instance2.LeftHand.localPosition = instance.LeftPos;
					instance2.LeftHand.localRotation = instance.LeftRot;
				}
				if ((Object)(object)instance2.RightHand != (Object)null)
				{
					instance2.RightHand.localPosition = instance.RightPos;
					instance2.RightHand.localRotation = instance.RightRot;
				}
				if ((Object)(object)val != (Object)null)
				{
					ClearTp();
					if (!((Behaviour)val).isActiveAndEnabled)
					{
						Transform val2 = ((Component)val).transform;
						while ((Object)(object)val2 != (Object)null)
						{
							if (!((Component)val2).gameObject.activeSelf)
							{
								((Component)val2).gameObject.SetActive(true);
							}
							val2 = val2.parent;
						}
						if (!((Behaviour)val).enabled)
						{
							((Behaviour)val).enabled = true;
						}
					}
					if ((Object)(object)val.targetTexture != (Object)null)
					{
						val.targetTexture = null;
					}
					CameraOutputPatches.EnsureXR(val);
					if (TryGetRagdollHead(out var pos))
					{
						if (VRConfig.DeathView.Value == DeathView.ThirdPerson)
						{
							RestoreDeadHead();
							Vector3 val3 = pos;
							try
							{
								DeadPlayer val4 = (((Object)(object)Player.LocalPlayer != (Object)null && (Object)(object)Player.LocalPlayer.Dying != (Object)null) ? Player.LocalPlayer.Dying.DeadPlayer : null);
								if ((Object)(object)val4 != (Object)null && (Object)(object)((Component)val4).transform != (Object)null)
								{
									val3 = ((Component)val4).transform.position;
								}
							}
							catch
							{
							}
							val3 += Vector3.up * 0.55f;
							Quaternion val5 = rotation * headRot;
							Vector3 eulerAngles = ((Quaternion)(ref val5)).eulerAngles;
							Quaternion val6 = Quaternion.Euler(Mathf.Clamp((eulerAngles.x > 180f) ? (eulerAngles.x - 360f) : eulerAngles.x, -85f, 85f), eulerAngles.y, 0f);
							float num = 2.6f;
							Vector3 val7 = val3 + val6 * (Vector3.forward * (0f - num));
							Vector3 val8 = val3 - val7;
							Vector3 normalized = ((Vector3)(ref val8)).normalized;
							RaycastHit val9 = default(RaycastHit);
							if (Physics.Raycast(val3, normalized, ref val9, num, LayerMask.op_Implicit(GameInfo.LevelLayer)))
							{
								val7 = ((RaycastHit)(ref val9)).point - normalized * 0.25f;
							}
							((Component)val).transform.position = val7;
							((Component)val).transform.rotation = rotation * headRot;
						}
						else
						{
							HideDeadHead();
							((Component)val).transform.position = pos;
							((Component)val).transform.rotation = rotation * headRot;
						}
					}
					else
					{
						RestoreDeadHead();
						((Component)val).transform.position = instance2.Root.TransformPoint(headPos);
						((Component)val).transform.rotation = rotation * headRot;
					}
				}
				else
				{
					Camera val10 = null;
					try
					{
						MainMenuManager instance3 = MainMenuManager._instance;
						if ((Object)(object)instance3 != (Object)null && (Object)(object)instance3._menuCam != (Object)null && ((Behaviour)instance3._menuCam).isActiveAndEnabled && (Object)(object)instance3._menuCam.targetTexture == (Object)null)
						{
							val10 = instance3._menuCam;
						}
					}
					catch
					{
					}
					Camera[] allCameras = Camera.allCameras;
					foreach (Camera val11 in allCameras)
					{
						if ((Object)(object)val10 == (Object)null && (Object)(object)val11 != (Object)null && ((Behaviour)val11).isActiveAndEnabled && (Object)(object)val11.targetTexture == (Object)null)
						{
							val10 = val11;
							break;
						}
					}
					if ((Object)(object)val10 != (Object)null)
					{
						Vector3 val12 = MenuBoatAnchor(val10);
						instance2.Root.position = val12 - rotation * headCalib;
						CameraOutputPatches.EnsureXR(val10);
						((Component)val10).transform.position = val12 + rotation * (headPos - headCalib);
						((Component)val10).transform.rotation = rotation * headRot;
					}
				}
				WaterUnderwaterPatches.UpdateFromRenderedVRView();
				VRDamageOverlay.Instance?.RepositionNow();
				try
				{
					Player localPlayer2 = Player.LocalPlayer;
					if ((Object)(object)localPlayer2 != (Object)null && (Object)(object)localPlayer2.Hands != (Object)null)
					{
						PlayerHandsPatches.ApplyTrackedHands(localPlayer2.Hands);
					}
					ArmRig.SolveCurrentPose(localPlayer2);
				}
				catch
				{
				}
				VRUIManager.Instance?.RepositionNow();
				try
				{
					XRSettings.gameViewRenderMode = (GameViewRenderMode)1;
				}
				catch
				{
				}
				VRDesktopMirror.Instance?.SyncToViewCamera();
			}
			catch
			{
			}
		}
	}
	[HarmonyPatch(typeof(ShaderManager))]
	public class VRDamageOverlay : MonoBehaviour
	{
		private Canvas _canvas;

		private Image _img;

		private Image _deathBackdrop;

		private float _deathBackdropAlpha;

		private readonly float _alphaMul = 0.95f;

		private const float NativeDeathBackdropAlpha = 0.4f;

		private const float NativeDeathFadeSpeed = 2.5f;

		public static VRDamageOverlay Instance { get; private set; }

		public static void Create()
		{
			//IL_0013: 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_001e: Expected O, but got Unknown
			if (!((Object)(object)Instance != (Object)null))
			{
				GameObject val = new GameObject("HowToFishVR DamageOverlay");
				Object.DontDestroyOnLoad((Object)val);
				Instance = val.AddComponent<VRDamageOverlay>();
				Instance.Build();
			}
		}

		private void Build()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Expected O, but got Unknown
			//IL_0059: 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_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: 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_0092: Expected O, but got Unknown
			//IL_00bd: 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_00c3: 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_00ce: 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_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: 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_0114: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_0131: Expected O, but got Unknown
			//IL_013b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0141: Expected O, but got Unknown
			//IL_016c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0171: 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_017c: 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_0187: Unknown result type (might be due to invalid IL or missing references)
			//IL_0188: 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_01b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0200: Expected O, but got Unknown
			GameObject val = new GameObject("Canvas");
			val.transform.SetParent(((Component)this).transform, false);
			val.layer = 5;
			_canvas = val.AddComponent<Canvas>();
			_canvas.renderMode = (RenderMode)2;
			_canvas.sortingOrder = 600;
			val.AddComponent<CanvasScaler>();
			RectTransform val2 = (RectTransform)val.transform;
			val2.sizeDelta = new Vector2(1920f, 1080f);
			((Transform)val2).localScale = Vector3.one * 0.0016f;
			GameObject val3 = new GameObject("DeathBackdrop");
			val3.transform.SetParent(val.transform, false);
			val3.layer = 5;
			_deathBackdrop = val3.AddComponent<Image>();
			RectTransform val4 = (RectTransform)val3.transform;
			val4.anchorMin = Vector2.zero;
			val4.anchorMax = Vector2.one;
			val4.offsetMin = Vector2.zero;
			val4.offsetMax = Vector2.zero;
			((Graphic)_deathBackdrop).color = Color.clear;
			((Graphic)_deathBackdrop).raycastTarget = false;
			try
			{
				((Graphic)_deathBackdrop).material = new Material(Canvas.GetDefaultCanvasMaterial())
				{
					name = "VR Native Death Backdrop",
					hideFlags = (HideFlags)61
				};
			}
			catch
			{
			}
			GameObject val5 = new GameObject("Vignette");
			val5.transform.SetParent(val.transform, false);
			val5.layer = 5;
			_img = val5.AddComponent<Image>();
			RectTransform val6 = (RectTransform)val5.transform;
			val6.anchorMin = Vector2.zero;
			val6.anchorMax = Vector2.one;
			val6.offsetMin = Vector2.zero;
			val6.offsetMax = Vector2.zero;
			((Graphic)_img).color = new Color(0f, 0f, 0f, 0f);
			((Graphic)_img).raycastTarget = false;
			try
			{
				_img.sprite = MakeDamageVignetteSprite();
			}
			catch
			{
			}
			try
			{
				Material material = new Material(Canvas.GetDefaultCanvasMaterial())
				{
					name = "VR DamageOverlay",
					hideFlags = (HideFlags)61
				};
				((Graphic)_img).material = material;
			}
			catch
			{
			}
			val.SetActive(false);
		}

		private void LateUpdate()
		{
			if (Plugin.VREnabled)
			{
				RepositionNow();
				UpdateDeathBackdrop();
			}
		}

		public void RepositionNow()
		{
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			if (!Plugin.VREnabled || (Object)(object)_canvas == (Object)null)
			{
				return;
			}
			VRRig instance = VRRig.Instance;
			if ((Object)(object)instance == (Object)null || (Object)(object)instance.Head == (Object)null)
			{
				return;
			}
			Transform val = instance.Head;
			try
			{
				Player localPlayer = Player.LocalPlayer;
				if ((Object)(object)localPlayer != (Object)null && (Object)(object)localPlayer.Camera != (Object)null && (Object)(object)localPlayer.Camera.Cam != (Object)null)
				{
					val = ((Component)localPlayer.Camera.Cam).transform;
				}
			}
			catch
			{
			}
			((Component)_canvas).transform.position = val.position + val.forward * 0.35f;
			((Component)_canvas).transform.rotation = val.rotation;
		}

		private void UpdateCanvasActive()
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)_canvas == (Object)null) && !((Object)(object)_img == (Object)null))
			{
				bool flag = ((Graphic)_img).color.a > 0.005f || _deathBackdropAlpha > 0.005f;
				if (((Component)_canvas).gameObject.activeSelf != flag)
				{
					((Component)_canvas).gameObject.SetActive(flag);
				}
			}
		}

		private void UpdateDeathBackdrop()
		{
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)_deathBackdrop == (Object)null))
			{
				bool flag = false;
				try
				{
					Player localPlayer = Player.LocalPlayer;
					flag = (Object)(object)localPlayer != (Object)null && (Object)(object)localPlayer.Dying != (Object)null && localPlayer.Dying.IsDead;
				}
				catch
				{
				}
				float num = (flag ? 0.4f : 0f);
				_deathBackdropAlpha = Mathf.Lerp(_deathBackdropAlpha, num, Mathf.Clamp01(Time.deltaTime * 2.5f));
				if (Mathf.Abs(_deathBackdropAlpha - num) < 0.001f)
				{
					_deathBackdropAlpha = num;
				}
				((Graphic)_deathBackdrop).color = new Color(0f, 0f, 0f, _deathBackdropAlpha);
				UpdateCanvasActive();
			}
		}

		private static Sprite MakeDamageVignetteSprite()
		{
			//IL_000c: 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_001c: 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_002c: Expected O, but got Unknown
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0109: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			Texture2D val = new Texture2D(256, 256, (TextureFormat)4, false)
			{
				name = "VR Damage Vignette Gradient",
				hideFlags = (HideFlags)61,
				wrapMode = (TextureWrapMode)1
			};
			for (int i = 0; i < 256; i++)
			{
				for (int j = 0; j < 256; j++)
				{
					float num = ((float)j + 0.5f) / 256f * 2f - 1f;
					float num2 = ((float)i + 0.5f) / 256f * 2f - 1f;
					float num3 = Mathf.Clamp01((Mathf.Sqrt(num * num + num2 * num2) - 0.55f) / 0.75f);
					float num4 = num3 * num3 * (3f - 2f * num3);
					val.SetPixel(j, i, new Color(0f, 0f, 0f, num4));
				}
			}
			val.Apply();
			return Sprite.Create(val, new Rect(0f, 0f, 256f, 256f), new Vector2(0.5f, 0.5f));
		}

		private void Apply(float intensity, Color color)
		{
			//IL_0031: 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_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)_img == (Object)null) && !((Object)(object)_canvas == (Object)null))
			{
				float num = Mathf.Clamp01(intensity * _alphaMul);
				((Graphic)_img).color = new Color(color.r, color.g, color.b, num);
				UpdateCanvasActive();
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch("UpdateVignette")]
		private static void OnUpdateVignette(float intensity, Color color)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			if (Plugin.VREnabled && (Object)(object)Instance != (Object)null)
			{
				Instance.Apply(intensity, color);
			}
		}
	}
	public class VRDesktopMirror : MonoBehaviour
	{
		private Camera _mirrorCam;

		private RenderTexture _rt;

		public static VRDesktopMirror Instance { get; private set; }

		public static void Create()
		{
			//IL_0013: 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_001e: Expected O, but got Unknown
			if (!((Object)(object)Instance != (Object)null))
			{
				GameObject val = new GameObject("HowToFishVR DesktopMirror");
				Object.DontDestroyOnLoad((Object)val);
				Instance = val.AddComponent<VRDesktopMirror>();
			}
		}

		private void Awake()
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Expected O, but got Unknown
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Expected O, but got Unknown
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Expected O, but got Unknown
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: 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_0115: 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_011b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0125: Unknown result type (might be due to invalid IL or missing references)
			//IL_0126: Unknown result type (might be due to invalid IL or missing references)
			//IL_0130: Unknown result type (might be due to invalid IL or missing references)
			//IL_0131: 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_0171: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				_rt = new RenderTexture(1280, 720, 24)
				{
					name = "HowToFishVR DesktopMirror RT"
				};
				GameObject val = new GameObject("HowToFishVR DesktopMirrorCam");
				val.transform.SetParent(((Component)this).transform, false);
				_mirrorCam = val.AddComponent<Camera>();
				_mirrorCam.targetTexture = _rt;
				((Behaviour)_mirrorCam).enabled = true;
				_mirrorCam.depth = -100f;
				_mirrorCam.stereoTargetEye = (StereoTargetEyeMask)0;
				try
				{
					UniversalAdditionalCameraData universalAdditionalCameraData = CameraExtensions.GetUniversalAdditionalCameraData(_mirrorCam);
					if ((Object)(object)universalAdditionalCameraData != (Object)null)
					{
						universalAdditionalCameraData.allowXRRendering = false;
						universalAdditionalCameraData.renderPostProcessing = false;
					}
				}
				catch
				{
				}
				GameObject val2 = new GameObject("HowToFishVR DesktopMirrorCanvas");
				val2.transform.SetParent(((Component)this).transform, false);
				Canvas obj2 = val2.AddComponent<Canvas>();
				obj2.renderMode = (RenderMode)0;
				obj2.sortingOrder = -1000;
				GameObject val3 = new GameObject("Mirror", new Type[1] { typeof(RectTransform) });
				val3.transform.SetParent(val2.transform, false);
				RectTransform val4 = (RectTransform)val3.transform;
				val4.anchorMin = Vector2.zero;
				val4.anchorMax = Vector2.one;
				val4.offsetMin = Vector2.zero;
				val4.offsetMax = Vector2.zero;
				RawImage obj3 = val3.AddComponent<RawImage>();
				obj3.texture = (Texture)(object)_rt;
				((Graphic)obj3).raycastTarget = false;
				obj3.uvRect = new Rect(0f, 0f, 1f, 1f);
			}
			catch
			{
			}
		}

		public void SyncToViewCamera()
		{
			//IL_0043: 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)
			try
			{
				if (!((Object)(object)_mirrorCam == (Object)null) && !((Object)(object)_rt == (Object)null))
				{
					Camera viewCamera = GetViewCamera();
					if (!((Object)(object)viewCamera == (Object)null))
					{
						((Component)_mirrorCam).transform.SetPositionAndRotation(((Component)viewCamera).transform.position, ((Component)viewCamera).transform.rotation);
						_mirrorCam.cullingMask = viewCamera.cullingMask;
						_mirrorCam.fieldOfView = viewCamera.fieldOfView;
						_mirrorCam.nearClipPlane = viewCamera.nearClipPlane;
						_mirrorCam.farClipPlane = viewCamera.farClipPlane;
					}
				}
			}
			catch
			{
			}
		}

		private static Camera GetViewCamera()
		{
			try
			{
				Player localPlayer = Player.LocalPlayer;
				if ((Object)(object)localPlayer != (Object)null && (Object)(object)localPlayer.Camera != (Object)null && (Object)(object)localPlayer.Camera.Cam != (Object)null && ((Behaviour)localPlayer.Camera.Cam).isActiveAndEnabled)
				{
					return localPlayer.Camera.Cam;
				}
			}
			catch
			{
			}
			Camera[] allCameras = Camera.allCameras;
			foreach (Camera val in allCameras)
			{
				if ((Object)(object)val != (Object)null && ((Behaviour)val).isActiveAndEnabled && (Object)(object)val.targetTexture == (Object)null)
				{
					return val;
				}
			}
			return null;
		}

		private void OnDestroy()
		{
			try
			{
				if ((Object)(object)_rt != (Object)null)
				{
					_rt.Release();
				}
			}
			catch
			{
			}
		}
	}
	[DefaultExecutionOrder(-500)]
	public class VRHeldItem : MonoBehaviour
	{
		private static Item _lastHeld;

		private static readonly List<Rigidbody> _frozen = new List<Rigidbody>();

		private static bool _fishTwoHand;

		private static Item _supportLatchItem;

		private const float FishLatchRadius = 0.3f;

		private static bool _revivePinned;

		private static Vector3 _reviveOffset;

		private static Quaternion _reviveRotOffset;

		private static Explosive _lighterGripItem;

		private static Vector3 _lighterFromHandPos;

		private static Quaternion _lighterFromHandRot = Quaternion.identity;

		private static bool _lighterFromHandValid;

		public static bool FishTwoHand => _fishTwoHand;

		public static void Create()
		{
			//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_0010: Expected O, but got Unknown
			GameObject val = new GameObject("HowToFishVR HeldItem");
			Object.DontDestroyOnLoad((Object)val);
			val.AddComponent<VRHeldItem>();
		}

		private void LateUpdate()
		{
			Pose();
		}

		private static void RestoreLastHeld()
		{
			if ((Object)(object)_lastHeld == (Object)null && _frozen.Count == 0)
			{
				return;
			}
			for (int i = 0; i < _frozen.Count; i++)
			{
				try
				{
					if ((Object)(object)_frozen[i] != (Object)null && _frozen[i].isKinematic)
					{
						_frozen[i].isKinematic = false;
					}
				}
				catch
				{
				}
			}
			_frozen.Clear();
			_lastHeld = null;
		}

		private static void ClearSupportHandLatch()
		{
			_fishTwoHand = false;
			_supportLatchItem = null;
		}

		private static void FreezeWholeItem(Item held)
		{
			//IL_0038: 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)
			_frozen.Clear();
			Rigidbody[] array = null;
			try
			{
				array = ((Component)held).GetComponentsInChildren<Rigidbody>(true);
			}
			catch
			{
			}
			if (array != null)
			{
				Rigidbody[] array2 = array;
				foreach (Rigidbody val in array2)
				{
					if (!((Object)(object)val == (Object)null) && !val.isKinematic)
					{
						val.linearVelocity = Vector3.zero;
						val.angularVelocity = Vector3.zero;
						val.isKinematic = true;
						_frozen.Add(val);
					}
				}
			}
			else if ((Object)(object)held.Rig != (Object)null && !held.Rig.isKinematic)
			{
				held.Rig.isKinematic = true;
				_frozen.Add(held.Rig);
			}
		}

		private static void FreezeRig(Rigidbody rb)
		{
			//IL_0013: 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)
			if (!((Object)(object)rb == (Object)null))
			{
				if (!rb.isKinematic)
				{
					rb.linearVelocity = Vector3.zero;
					rb.angularVelocity = Vector3.zero;
				}
				rb.isKinematic = true;
			}
		}

		private static bool TryGetHandPoseLocal(Item held, HandTransforms ht, out Vector3 localPos, out Quaternion localRot)
		{
			//IL_0001: 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_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_0052: 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_0062: 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_006b: 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_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_0086: 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_008c: Unknown result type (might be due to invalid IL or missing references)
			localPos = default(Vector3);
			localRot = Quaternion.identity;
			if ((Object)(object)held == (Object)null || ht == null || !ht.Exists)
			{
				return false;
			}
			try
			{
				Transform obj = (((Object)(object)ht.Parent != (Object)null) ? ht.Parent : ((Component)held).transform);
				Vector3 val = obj.TransformPoint(ht.HandPos);
				Quaternion val2 = obj.rotation * ht.HandRot;
				localPos = ((Component)held).transform.InverseTransformPoint(val);
				localRot = Quaternion.Inverse(((Component)held).transform.rotation) * val2;
				return true;
			}
			catch
			{
				return false;
			}
		}

		private void Pose()
		{
			//IL_027a: Unknown result type (might be due to invalid IL or missing references)
			//IL_027c: Unknown result type (might be due to invalid IL or missing references)
			//IL_027e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0280: Unknown result type (might be due to invalid IL or missing references)
			//IL_0238: Unknown result type (might be due to invalid IL or missing references)
			//IL_023d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0242: Unknown result type (might be due to invalid IL or missing references)
			//IL_0249: Unknown result type (might be due to invalid IL or missing references)
			//IL_024e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0253: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f9: 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_0205: 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_0211: Unknown result type (might be due to invalid IL or missing references)
			//IL_0216: Unknown result type (might be due to invalid IL or missing references)
			//IL_0221: 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_022b: Unknown result type (might be due to invalid IL or missing references)
			//IL_028e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0293: Unknown result type (might be due to invalid IL or missing references)
			//IL_0297: Unknown result type (might be due to invalid IL or missing references)
			//IL_029c: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c2: 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_0335: Unknown result type (might be due to invalid IL or missing references)
			//IL_033c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0350: Unknown result type (might be due to invalid IL or missing references)
			//IL_0355: Unknown result type (might be due to invalid IL or missing references)
			//IL_035a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0361: Unknown result type (might be due to invalid IL or missing references)
			//IL_02db: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_02eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0300: Unknown result type (might be due to invalid IL or missing references)
			//IL_0305: 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_0309: Unknown result type (might be due to invalid IL or missing references)
			//IL_030e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0313: 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)
			//IL_031d: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if (!Plugin.HeadsetActive)
				{
					RestoreLastHeld();
					ClearSupportHandLatch();
					return;
				}
				VRRig instance = VRRig.Instance;
				if ((Object)(object)instance == (Object)null || (Object)(object)instance.RightHand == (Object)null || (Object)(object)instance.LeftHand == (Object)null)
				{
					RestoreLastHeld();
					ClearSupportHandLatch();
					return;
				}
				Player val = null;
				try
				{
					val = Player.LocalPlayer;
				}
				catch
				{
				}
				if ((Object)(object)val == (Object)null)
				{
					RestoreLastHeld();
					ClearSupportHandLatch();
					return;
				}
				try
				{
					if (Boat.IsDrivingLocally)
					{
						RestoreLastHeld();
						ClearSupportHandLatch();
						return;
					}
				}
				catch
				{
				}
				Item val2 = null;
				try
				{
					val2 = (((Object)(object)val.Holding != (Object)null) ? val.Holding.HeldItem : null);
				}
				catch
				{
				}
				if ((Object)(object)val2 == (Object)null)
				{
					RestoreLastHeld();
					ClearSupportHandLatch();
					return;
				}
				if (val2 is Tool)
				{
					RestoreLastHeld();
					ClearSupportHandLatch();
					return;
				}
				if ((Object)(object)((Component)val2).transform == (Object)null)
				{
					RestoreLastHeld();
					ClearSupportHandLatch();
					return;
				}
				if (HeldItemHoldPatches.ShouldHandHold(val.Holding))
				{
					RestoreLastHeld();
					_lastHeld = null;
					if ((Object)(object)_supportLatchItem != (Object)(object)val2)
					{
						_fishTwoHand = false;
						_supportLatchItem = val2;
					}
					UpdateFishTwoHand(instance, val2);
					return;
				}
				ClearSupportHandLatch();
				if ((Object)(object)val2 != (Object)(object)_lastHeld)
				{
					RestoreLastHeld();
					_fishTwoHand = false;
					FreezeWholeItem(val2);
					_lastHeld = val2;
				}
				_ = (Object)(object)val2.HandModelRight != (Object)null;
				_ = (Object)(object)val2.HandModelLeft != (Object)null;
				Vector3 localPos;
				Quaternion localRot;
				bool flag = TryGetHandPoseLocal(val2, val2.HandTransformsRight, out localPos, out localRot);
				TryGetHandPoseLocal(val2, val2.HandTransformsLeft, out var _, out var _);
				bool flag2 = false;
				try
				{
					flag2 = ((DeadPlayer)(((val2 is DeadPlayer) ? val2 : null)?))._isResurrecting ?? false;
				}
				catch
				{
				}
				Transform mainHand = instance.MainHand;
				if ((Object)(object)mainHand == (Object)null)
				{
					RestoreLastHeld();
					return;
				}
				if (flag2)
				{
					if (!_revivePinned)
					{
						_revivePinned = true;
						_reviveOffset = ((Component)val2).transform.position - mainHand.position;
						_reviveRotOffset = Quaternion.Inverse(mainHand.rotation) * ((Component)val2).transform.rotation;
					}
					((Component)val2).transform.SetPositionAndRotation(mainHand.position + _reviveOffset, mainHand.rotation * _reviveRotOffset);
					PinExplosiveLighter(instance, val2);
					return;
				}
				_revivePinned = false;
				try
				{
					Transform handModelRight = val2.HandModelRight;
					bool flag3 = flag;
					Vector3 val3 = localPos;
					Quaternion val4 = localRot;
					if ((Object)(object)handModelRight != (Object)null)
					{
						Quaternion rotation = mainHand.rotation;
						Vector3 val5 = mainHand.position - rotation * ((Component)val2).transform.InverseTransformPoint(handModelRight.position);
						((Component)val2).transform.SetPositionAndRotation(val5, rotation);
						PinExplosiveLighter(instance, val2);
						return;
					}
					if (flag3)
					{
						Quaternion rightGripOffset = PlayerHandsPatches.RightGripOffset;
						Quaternion val6 = mainHand.rotation * rightGripOffset * Quaternion.Inverse(val4);
						Vector3 val7 = mainHand.position - val6 * val3;
						((Component)val2).transform.SetPositionAndRotation(val7, val6);
						PinExplosiveLighter(instance, val2);
						return;
					}
					((Component)val2).transform.SetPositionAndRotation(mainHand.position + mainHand.rotation * new Vector3(0f, -0.06f, 0.2f), mainHand.rotation);
				}
				catch
				{
				}
				PinExplosiveLighter(instance, val2);
			}
			catch
			{
			}
		}

		private static void PinExplosiveLighter(VRRig rig, Item held)
		{
			//IL_01d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_019a: 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_01aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_01af: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ba: 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_00fe: 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_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: 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_011d: Unknown result type (might be due to invalid IL or missing references)
			//IL_012e: 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_0145: Unknown result type (might be due to invalid IL or missing references)
			//IL_014b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0150: Unknown result type (might be due to invalid IL or missing references)
			//IL_0155: Unknown result type (might be due to invalid IL or missing references)
			//IL_0157: Unknown result type (might be due to invalid IL or missing references)
			//IL_0158: Unknown result type (might be due to invalid IL or missing references)
			//IL_015d: Unknown result type (might be due to invalid IL or missing references)
			//IL_015f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0161: Unknown result type (might be due to invalid IL or missing references)
			//IL_0166: Unknown result type (might be due to invalid IL or missing references)
			//IL_016b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0170: Unknown result type (might be due to invalid IL or missing references)
			//IL_0175: Unknown result type (might be due to invalid IL or missing references)
			//IL_0177: Unknown result type (might be due to invalid IL or missing references)
			//IL_017c: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				Explosive val = (Explosive)(object)((held is Explosive) ? held : null);
				if (val == null || (Object)(object)val._lighter == (Object)null || !((Component)val._lighter).gameObject.activeInHierarchy || val._isActivated || val._lighterPickupPercent < 1f)
				{
					return;
				}
				Player localPlayer = Player.LocalPlayer;
				PlayerHands val2 = (((Object)(object)localPlayer != (Object)null) ? localPlayer.Hands : null);
				if ((Object)(object)val2 == (Object)null)
				{
					return;
				}
				Transform handBoneLeft = val2.HandBoneLeft;
				if ((Object)(object)handBoneLeft == (Object)null)
				{
					return;
				}
				if ((Object)(object)_lighterGripItem != (Object)(object)val)
				{
					_lighterGripItem = val;
					_lighterFromHandValid = false;
				}
				if (!_lighterFromHandValid)
				{
					try
					{
						HandTransforms handTransformsLeft = ((Item)val).HandTransformsLeft;
						if (handTransformsLeft != null && handTransformsLeft.Exists && (Object)(object)handTransformsLeft.Parent != (Object)null && (Object)(object)val._lighter.parent != (Object)null)
						{
							Vector3 val3 = handTransformsLeft.Parent.TransformPoint(handTransformsLeft.HandPos);
							Quaternion val4 = handTransformsLeft.Parent.rotation * handTransformsLeft.HandRot;
							Vector3 val5 = val._lighter.parent.TransformPoint(val._lighterOrigPos);
							Quaternion val6 = val._lighter.parent.rotation * val._lighterOrigRot;
							_lighterFromHandPos = Quaternion.Inverse(val4) * (val5 - val3);
							_lighterFromHandRot = Quaternion.Inverse(val4) * val6;
							_lighterFromHandValid = true;
						}
					}
					catch
					{
					}
				}
				if (_lighterFromHandValid)
				{
					val._lighter.SetPositionAndRotation(handBoneLeft.position + handBoneLeft.rotation * _lighterFromHandPos, handBoneLeft.rotation * _lighterFromHandRot);
				}
				else
				{
					val._lighter.SetPositionAndRotation(handBoneLeft.position, handBoneLeft.rotation);
				}
			}
			catch
			{
			}
		}

		private static void UpdateFishTwoHand(VRRig rig, Item held)
		{
			//IL_007f: 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_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: 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_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: 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_00f3: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if (held is Fish || (Object)(object)held.Fish != (Object)null)
				{
					_fishTwoHand = false;
					return;
				}
				Transform leftHand = rig.LeftHand;
				if ((Object)(object)leftHand == (Object)null || (Object)(object)leftHand == (Object)(object)rig.MainHand)
				{
					_fishTwoHand = false;
					return;
				}
				bool flag = VRActions.Instance.LeftGrip.ReadValue<float>() >= VRConfig.GripThreshold.Value;
				bool flag2 = false;
				Vector3 val;
				if ((Object)(object)held.HandModelLeft != (Object)null)
				{
					val = held.HandModelLeft.position;
					flag2 = true;
				}
				else if (held.HandTransformsLeft != null && held.HandTransformsLeft.Exists && (Object)(object)held.HandTransformsLeft.Parent != (Object)null)
				{
					val = held.HandTransformsLeft.Parent.TransformPoint(held.HandTransformsLeft.HandPos);
					flag2 = true;
				}
				else
				{
					val = leftHand.position;
				}
				if (!flag2)
				{
					_fishTwoHand = false;
				}
				else if (!_fishTwoHand)
				{
					if (flag && Vector3.Distance(leftHand.position, val) <= 0.3f)
					{
						_fishTwoHand = true;
					}
				}
				else if (!flag)
				{
					_fishTwoHand = false;
				}
			}
			catch
			{
			}
		}
	}
	[DefaultExecutionOrder(-1000)]
	public class VRRig : MonoBehaviour
	{
		public float YawOffset;

		public float GameEyeHeight = 1.5f;

		private bool _snapReady = true;

		private float _invScrollCd;

		private bool _calibrated;

		private Vector3 _headCalib;

		private float _yHoldTime;

		private Vector3 _lastHead;

		private bool _lastHeadValid;

		private Vector3 _roomOffset;

		private Vector2 _lastHmdPlanar;

		private bool _planarInit;

		private bool _needsReanchor;

		private bool _wasDead;

		private Vector3 _deathAnchor;

		private bool _setGameView;

		private bool _gameHeightSet;

		private bool _sprintToggle;

		private bool _crouchToggle;

		private bool _physCrouch;

		private const float PhysCrouchEngageDrop = 0.22f;

		private const float PhysCrouchReleaseDrop = 0.14f;

		private Boat _drivingBoat;

		private float _lastBoatYaw;

		private bool _boatYawInit;

		public static VRRig Instance { get; private set; }

		public Transform Root { get; private set; }

		public Transform Head { get; private set; }

		public Transform LeftHand { get; private set; }

		public Transform RightHand { get; private set; }

		public Transform MainHand => RightHand;

		public Transform OffHand => LeftHand;

		public bool SnapTurned { get; private set; }

		public float SnapTurnYaw { get; private set; }

		public bool IsCalibrated => _calibrated;

		public Vector3 HeadCalib => _headCalib;

		public static void Create()
		{
			//IL_0013: 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_001e: Expected O, but got Unknown
			if (!((Object)(object)Instance != (Object)null))
			{
				GameObject val = new GameObject("HowToFishVR Rig");
				Object.DontDestroyOnLoad((Object)val);
				Instance = val.AddComponent<VRRig>();
				Instance.Build();
			}
		}

		private void Build()
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: 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)
			Root = ((Component)this).transform;
			Head = new GameObject("Head").transform;
			LeftHand = new GameObject("LeftHand").transform;
			RightHand = new GameObject("RightHand").transform;
			Head.SetParent(Root, false);
			LeftHand.SetParent(Root, false);
			RightHand.SetParent(Root, false);
			try
			{
				if (VRConfig.SavedEyeHeight.Value > 0.2f)
				{
					GameEyeHeight = VRConfig.SavedEyeHeight.Value;
					_gameHeightSet = true;
				}
			}
			catch
			{
			}
		}

		private void Update()
		{
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0304: Unknown result type (might be due to invalid IL or missing references)
			//IL_0315: Unknown result type (might be due to invalid IL or missing references)
			//IL_0326: Unknown result type (might be due to invalid IL or missing references)
			//IL_0337: Unknown result type (might be due to invalid IL or missing references)
			//IL_0348: Unknown result type (might be due to invalid IL or missing references)
			//IL_035d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0362: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_02be: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_02cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02da: 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)
			//IL_026e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0279: Unknown result type (might be due to invalid IL or missing references)
			//IL_027e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0283: Unknown result type (might be due to invalid IL or missing references)
			//IL_028b: Unknown result type (might be due to invalid IL or missing references)
			//IL_028d: Unknown result type (might be due to invalid IL or missing references)
			//IL_028f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0290: Unknown result type (might be due to invalid IL or missing references)
			//IL_0295: 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_00d3: 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_0228: 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_013d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: Unknown result type (might be due to invalid IL or missing references)
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: 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_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0259: Unknown result type (might be due to invalid IL or missing references)
			//IL_025e: 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_01f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_015c: Unknown result type (might be due to invalid IL or missing references)
			//IL_015e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0163: 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_0179: Unknown result type (might be due to invalid IL or missing references)
			//IL_017a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0180: 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_018b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0191: Unknown result type (might be due to invalid IL or missing references)
			//IL_0197: Unknown result type (might be due to invalid IL or missing references)
			//IL_019c: Unknown result type (might be due to invalid IL or missing references)
			VRActions instance = VRActions.Instance;
			if (instance == null)
			{
				return;
			}
			if (!Application.runInBackground)
			{
				Application.runInBackground = true;
			}
			if (!_setGameView)
			{
				_setGameView = true;
				try
				{
					XRSettings.gameViewRenderMode = (GameViewRenderMode)1;
				}
				catch
				{
				}
			}
			Player localPlayer = Player.LocalPlayer;
			if ((Object)(object)localPlayer != (Object)null)
			{
				VRBindings.TryInject();
			}
			if ((Object)(object)localPlayer != (Object)null && !_gameHeightSet)
			{
				try
				{
					if ((Object)(object)localPlayer.Camera != (Object)null)
					{
						GameEyeHeight = localPlayer.Camera.CamHeight;
						_gameHeightSet = true;
					}
				}
				catch
				{
				}
			}
			CameraOutputPatches.EnsureAll();
			bool flag = false;
			try
			{
				flag = (Object)(object)localPlayer != (Object)null && (Object)(object)localPlayer.Dying != (Object)null && localPlayer.Dying.IsDead;
			}
			catch
			{
			}
			Vector3 headPos = instance.HeadPos;
			if (!_calibrated && ((Vector3)(ref headPos)).sqrMagnitude > 1E-06f)
			{
				_headCalib = headPos;
				_calibrated = true;
			}
			if (_needsReanchor && ((Vector3)(ref headPos)).sqrMagnitude > 1E-06f)
			{
				_needsReanchor = false;
				_roomOffset = Vector3.zero;
				_lastHmdPlanar = new Vector2(headPos.x, headPos.z);
				_planarInit = true;
			}
			if (((Vector3)(ref _roomOffset)).magnitude > 10f)
			{
				_roomOffset = Vector3.zero;
				_planarInit = false;
			}
			if (_calibrated && _lastHeadValid && !flag)
			{
				Vector3 val = headPos - _lastHead;
				if (((Vector3)(ref val)).magnitude > 0.35f)
				{
					_headCalib = headPos;
					_roomOffset = Vector3.zero;
					_lastHmdPlanar = new Vector2(headPos.x, headPos.z);
				}
			}
			_lastHead = headPos;
			_lastHeadValid = true;
			HandleTurning();
			FollowBoatYaw();
			Quaternion val2 = Quaternion.Euler(0f, YawOffset, 0f);
			if ((Object)(object)localPlayer == (Object)null)
			{
				try
				{
					if (VRCameraPoser_Behaviour.TryGetCustomizationOrigin(instance.HeadRot, YawOffset, out var origin))
					{
						val2 = origin;
					}
				}
				catch
				{
				}
			}
			_wasDead = flag;
			if ((Object)(object)localPlayer != (Object)null && (Object)(object)localPlayer.Transform != (Object)null)
			{
				Vector3 position = localPlayer.Transform.position;
				bool flag2 = false;
				if ((Object)(object)_drivingBoat != (Object)null)
				{
					try
					{
						if ((Object)(object)_drivingBoat.DriverPos != (Object)null)
						{
							position = _drivingBoat.DriverPos.position;
							flag2 = true;
						}
					}
					catch
					{
					}
				}
				if (flag2)
				{
					Vector3 val3 = position + Vector3.up * GameEyeHeight;
					Root.position = val3 - val2 * headPos;
				}
				else
				{
					Vector3 val4 = position - _roomOffset + Vector3.up * GameEyeHeight;
					Root.position = val4 - val2 * _headCalib;
				}
			}
			Root.rotation = val2;
			Head.localPosition = headPos;
			Head.localRotation = instance.HeadRot;
			LeftHand.localPosition = instance.LeftPos;
			LeftHand.localRotation = instance.LeftRot;
			RightHand.localPosition = instance.RightPos;
			RightHand.localRotation = instance.RightRot;
			ApplySprintCrouch();
			KeyboardShortcut value = VRConfig.RecenterKey.Value;
			if (((KeyboardShortcut)(ref value)).IsDown())
			{
				Recenter();
			}
		}

		private void FixedUpdate()
		{
			//IL_007f: 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_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: 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_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: 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_00a9: 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_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: 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_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_011e: 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_012c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0131: 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)
			if (!Plugin.VREnabled)
			{
				return;
			}
			VRActions instance = VRActions.Instance;
			if (instance == null)
			{
				return;
			}
			if (!VRConfig.RoomscaleMovement.Value)
			{
				_planarInit = false;
				return;
			}
			Player localPlayer = Player.LocalPlayer;
			Rigidbody val = (((Object)(object)localPlayer != (Object)null) ? localPlayer.Rigidbody : null);
			if ((Object)(object)localPlayer == (Object)null || (Object)(object)val == (Object)null)
			{
				_planarInit = false;
				return;
			}
			bool flag = false;
			try
			{
				flag = Boat.IsDrivingLocally || localPlayer.Dying.IsDead || localPlayer.BlockInputs;
			}
			catch
			{
			}
			Vector3 headPos = instance.HeadPos;
			Vector2 val2 = default(Vector2);
			((Vector2)(ref val2))..ctor(headPos.x, headPos.z);
			if (!_planarInit || flag)
			{
				_lastHmdPlanar = val2;
				_planarInit = true;
				return;
			}
			Vector2 val3 = val2 - _lastHmdPlanar;
			_lastHmdPlanar = val2;
			if (!(((Vector2)(ref val3)).sqrMagnitude < 1E-08f) && !(((Vector2)(ref val3)).magnitude > 0.5f))
			{
				Vector3 val4 = Root.rotation * new Vector3(val3.x, 0f, val3.y);
				val.MovePosition(val.position + val4);
				_roomOffset += val4;
			}
		}

		public void CalibrateNow()
		{
			//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_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_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_00c2: 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_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			VRActions instance = VRActions.Instance;
			if (instance != null)
			{
				_headCalib = instance.HeadPos;
				_lastHmdPlanar = new Vector2(_headCalib.x, _headCalib.z);
				_planarInit = true;
			}
			try
			{
				Player localPlayer = Player.LocalPlayer;
				if ((Object)(object)localPlayer != (Object)null && (Object)(object)localPlayer.Camera != (Object)null && localPlayer.Camera.CamHeight > 0.2f)
				{
					GameEyeHeight = localPlayer.Camera.CamHeight;
					_gameHeightSet = true;
				}
				else
				{
					GameEyeHeight = _headCalib.y;
				}
			}
			catch
			{
			}
			_roomOffset = Vector3.zero;
			_calibrated = true;
			Recenter();
			_lastHmdPlanar = (Vector2)((instance != null) ? new Vector2(instance.HeadPos.x, instance.HeadPos.z) : _lastHmdPlanar);
			_planarInit = true;
			try
			{
				VRConfig.SavedEyeHeight.Value = GameEyeHeight;
				VRConfig.SavedHeadCalibY.Value = _headCalib.y;
			}
			catch
			{
			}
			try
			{
				HowToFishBody.ApplyBodyMode();
			}
			catch
			{
			}
		}

		public void OnRespawn()
		{
			_needsReanchor = true;
		}

		private void ApplySprintCrouch()
		{
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			Player localPlayer = Player.LocalPlayer;
			if ((Object)(object)localPlayer == (Object)null || (Object)(object)localPlayer.Movement == (Object)null)
			{
				return;
			}
			VRActions instance = VRActions.Instance;
			bool sprintInput;
			if (VRConfig.SprintMode.Value == ButtonMode.Hold)
			{
				sprintInput = instance.SprintButton.IsPressed();
			}
			else
			{
				if (instance.SprintButton.WasPressedThisFrame())
				{
					_sprintToggle = !_sprintToggle;
				}
				sprintInput = _sprintToggle;
			}
			bool crouchInput;
			if (VRConfig.CrouchMode.Value == ButtonMode.Hold)
			{
				crouchInput = instance.CrouchButton.IsPressed();
			}
			else
			{
				if (instance.CrouchButton.WasPressedThisFrame())
				{
					_crouchToggle = !_crouchToggle;
				}
				crouchInput = _crouchToggle;
			}
			if (VRConfig.RoomscaleMovement.Value && _calibrated)
			{
				float num = _headCalib.y - instance.HeadPos.y;
				if (_physCrouch)
				{
					if (num < 0.14f)
					{
						_physCrouch = false;
					}
				}
				else if (num >= 0.22f)
				{
					_physCrouch = true;
				}
				if (_physCrouch)
				{
					crouchInput = true;
				}
			}
			localPlayer.Movement._sprintInput = sprintInput;
			localPlayer.Movement._crouchInput = crouchInput;
		}

		private void FollowBoatYaw()
		{
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			bool flag = false;
			try
			{
				flag = Boat.IsDrivingLocally;
			}
			catch
			{
			}
			if (!flag)
			{
				_drivingBoat = null;
				_boatYawInit = false;
				return;
			}
			if ((Object)(object)_drivingBoat == (Object)null)
			{
				try
				{
					Boat[] array = Object.FindObjectsByType<Boat>((FindObjectsSortMode)0);
					foreach (Boat val in array)
					{
						if ((Object)(object)val != (Object)null && (Object)(object)val.Driver == (Object)(object)Player.LocalPlayer)
						{
							_drivingBoat = val;
							break;
						}
					}
				}
				catch
				{
				}
			}
			if ((Object)(object)_drivingBoat == (Object)null)
			{
				return;
			}
			Transform val2 = null;
			try
			{
				val2 = _drivingBoat.DriverPos;
			}
			catch
			{
			}
			if ((Object)(object)val2 == (Object)null)
			{
				try
				{
					val2 = _drivingBoat.VisualBoat;
				}
				catch
				{
				}
			}
			if (!((Object)(object)val2 == (Object)null))
			{
				float y = val2.eulerAngles.y;
				if (!_boatYawInit)
				{
					_lastBoatYaw = y;
					_boatYawInit = true;
				}
				else
				{
					YawOffset += Mathf.DeltaAngle(_lastBoatYaw, y);
					_lastBoatYaw = y;
				}
			}
		}

		private void HandleTurning()
		{
			//IL_009c: 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_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: 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_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			SnapTurned = false;
			VRActions instance = VRActions.Instance;
			if (instance == null)
			{
				return;
			}
			float num = instance.TurnAxis.ReadValue<float>();
			if (VRConfig.Turning.Value == TurnMode.Snap)
			{
				if (Mathf.Abs(num) < 0.35f)
				{
					_snapReady = true;
				}
				else if (_snapReady && Mathf.Abs(num) >= 0.75f)
				{
					_snapReady = false;
					ArmRig.PrepareForSnapTurn();
					RotateYawAboutHead(Mathf.Sign(num) * (float)VRConfig.SnapTurnAngle.Value);
					SnapTurned = true;
					Quaternion val = Quaternion.Euler(0f, YawOffset, 0f) * instance.HeadRot;
					SnapTurnYaw = ((Quaternion)(ref val)).eulerAngles.y;
					try
					{
						InputDevice deviceAtXRNode = InputDevices.GetDeviceAtXRNode((XRNode)5);
						if (((InputDevice)(ref deviceAtXRNode)).isValid)
						{
							((InputDevice)(ref deviceAtXRNode)).SendHapticImpulse(0u, 0.35f, 0.06f);
						}
					}
					catch
					{
					}
				}
			}
			else if (Mathf.Abs(num) >= 0.15f)
			{
				float num2 = (Mathf.Abs(num) - 0.15f) / 0.85f;
				RotateYawAboutHead(Mathf.Sign(num) * num2 * VRConfig.SmoothTurnSpeed.Value * Time.deltaTime);
			}
			if (_invScrollCd > 0f)
			{
				_invScrollCd -= Time.deltaTime;
			}
			float num3 = instance.TurnAxisY.ReadValue<float>();
			bool flag = true;
			try
			{
				Player localPlayer = Player.LocalPlayer;
				if ((Object)(object)localPlayer == (Object)null)
				{
					flag = false;
				}
				else if ((Object)(object)localPlayer.Dying != (Object)null && localPlayer.Dying.IsDead)
				{
					flag = false;
				}
				else if (localPlayer.BlockInputs)
				{
					flag = false;
				}
				else if (Boat.IsDrivingLocally)
				{
					flag = false;
				}
			}
			catch
			{
			}
			if (flag && Mathf.Abs(num3) >= 0.7f && _invScrollCd <= 0f)
			{
				_invScrollCd = 0.25f;
				ScrollInventory((!(num3 > 0f)) ? 1 : (-1));
			}
		}

		private static void ScrollInventory(int dir)
		{
			try
			{
				Player localPlayer = Player.LocalPlayer;
				if ((Object)(object)localPlayer == (Object)null || (Object)(object)localPlayer.Inventory == (Object)null)
				{
					return;
				}
				List<InventorySlot> availableSlots = localPlayer.Inventory._availableSlots;
				if (availableSlots != null && availableSlots.Count != 0)
				{
					int num = localPlayer.Inventory._localCurSlot + dir;
					if (num < 0)
					{
						num = availableSlots.Count - 1;
					}
					else if (num >= availableSlots.Count)
					{
						num = 0;
					}
					localPlayer.Inventory.LocalTrySelectSlot(num);
				}
			}
			catch
			{
			}
		}

		private void RotateYawAboutHead(float deltaDeg)
		{
			//IL_0019: 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)
			//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_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: 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_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_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: 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_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)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			if (!(Mathf.Abs(deltaDeg) < 0.0001f))
			{
				VRActions instance = VRActions.Instance;
				if (instance != null)
				{
					Vector3 val = instance.HeadPos - _headCalib;
					Quaternion val2 = Quaternion.Euler(0f, YawOffset, 0f);
					YawOffset += deltaDeg;
					Quaternion val3 = Quaternion.Euler(0f, YawOffset, 0f);
					_roomOffset += val3 * val - val2 * val;
				}
			}
		}

		public void Recenter()
		{
			//IL_0010: 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_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_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_0038: 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_0041: 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_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: 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_007b: 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_0081: 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_008b: Unknown result type (might be due to invalid IL or missing references)
			VRActions instance = VRActions.Instance;
			if (instance != null)
			{
				ArmRig.PrepareForSnapTurn();
				Vector3 val = instance.HeadPos - _headCalib;
				Quaternion val2 = Quaternion.Euler(0f, YawOffset, 0f);
				Quaternion headRot = instance.HeadRot;
				float y = ((Quaternion)(ref headRot)).eulerAngles.y;
				YawOffset = 0f - y;
				Quaternion val3 = Quaternion.Euler(0f, YawOffset, 0f);
				_roomOffset += val3 * val - val2 * val;
				_planarInit = false;
				VRCameraPoser.Instance?.Recalibrate();
			}
		}

		public Quaternion MovementHeading()
		{
			//IL_001a: 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)
			//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_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)
			Vector3 forward = (VRConfig.HeadRelativeMovement.Value ? Head : OffHand).forward;
			forward.y = 0f;
			if (((Vector3)(ref forward)).sqrMagnitude < 0.0001f)
			{
				forward = Root.forward;
			}
			return Quaternion.LookRotation(((Vector3)(ref forward)).normalized, Vector3.up);
		}
	}
}
namespace HowToFishVR.UI
{
	[DefaultExecutionOrder(-1000)]
	public class VRLaser : MonoBehaviour
	{
		private sealed class Ray
		{
			public GameObject Go;

			public LineRenderer Line;

			public bool Left;
		}

		private Ray _right;

		private static EventSystem _configuredEventSystem;

		private const float Length = 5f;

		internal static readonly Quaternion PointerTilt = Quaternion.Euler(45f, 0f, 0f);

		public static VRLaser Instance { get; private set; }

		public static void Create()
		{
			//IL_0013: 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_001e: Expected O, but got Unknown
			if (!((Object)(object)Instance != (Object)null))
			{
				GameObject val = new GameObject("HowToFishVR Laser");
				Object.DontDestroyOnLoad((Object)val);
				Instance = val.AddComponent<VRLaser>();
				Instance.Init();
			}
		}

		private void Init()
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Expected O, but got Unknown
			_right = BuildRay(left: false);
			Application.onBeforeRender += new UnityAction(PoseAndDraw);
		}

		private void OnDestroy()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Expected O, but got Unknown
			Application.onBeforeRender -= new UnityAction(PoseAndDraw);
		}

		private static VRPointerInputModule EnsureModule()
		{
			EventSystem current = EventSystem.current;
			if ((Object)(object)current == (Object)null)
			{
				return null;
			}
			BaseInputModule[] components = ((Component)current).GetComponents<BaseInputModule>();
			foreach (BaseInputModule val in components)
			{
				if (!(val is VRPointerInputModule))
				{
					((Behaviour)val).enabled = false;
				}
			}
			VRPointerInputModule vRPointerInputModule = ((Component)current).GetComponent<VRPointerInputModule>();
			if ((Object)(object)vRPointerInputModule == (Object)null)
			{
				vRPointerInputModule = ((Component)current).gameObject.AddComponent<VRPointerInputModule>();
			}
			((Behaviour)vRPointerInputModule).enabled = true;
			if ((Object)(object)_configuredEventSystem != (Object)(object)current)
			{
				_configuredEventSystem = current;
			}
			return vRPointerInputModule;
		}

		private Ray BuildRay(bool left)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Expected O, but got Unknown
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Expected O, but got Unknown
			//IL_00bb: 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_00c0: 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_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: 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_00e0: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject(left ? "LeftRay" : "RightRay");
			val.layer = 5;
			val.transform.SetParent(((Component)this).transform, false);
			LineRenderer val2 = val.AddComponent<LineRenderer>();
			val2.useWorldSpace = true;
			val2.positionCount = 2;
			val2.widthMultiplier = 0.006f;
			val2.numCapVertices = 2;
			Shader val3 = Shader.Find("Universal Render Pipeline/Unlit") ?? Shader.Find("Sprites/Default");
			if ((Object)(object)val3 != (Object)null)
			{
				((Renderer)val2).material = new Material(val3);
				((Renderer)val2).material.renderQueue = 4000;
			}
			Color val4 = (val2.startColor = (left ? new Color(1f, 0.72f, 0.2f) : new Color(0.25f, 0.85f, 1f)));
			val2.endColor = new Color(val4.r, val4.g, val4.b, 0.3f);
			Ray result = new Ray
			{
				Go = val,
				Line = val2,
				Left = left
			};
			val.SetActive(false);
			return result;
		}

		internal static bool LaserActive()
		{
			try
			{
				if (MainMenuManager.IsInMenu)
				{
					return true;
				}
			}
			catch
			{
			}
			try
			{
				if (PauseManager.IsPaused)
				{
					return true;
				}
			}
			catch
			{
			}
			try
			{
				if (VRSettingsPanel.IsOpen)
				{
					return true;
				}
			}
			catch
			{
			}
			return false;
		}

		private void Update()
		{
			VRPointerInputModule vRPointerInputModule = EnsureModule();
			bool flag = LaserActive();
			SetRayActive(_right, flag);
			if ((Object)(object)vRPointerInputModule != (Object)null)
			{
				vRPointerInputModule.SetLaserActive(flag);
			}
			if (flag)
			{
				PoseTransform(_right);
			}
		}

		private static void SetRayActive(Ray r, bool active)
		{
			if ((Object)(object)r?.Go != (Object)null && r.Go.activeSelf != active)
			{
				r.Go.SetActive(active);
			}
		}

		private void PoseAndDraw()
		{
			bool flag = LaserActive();
			if ((Object)(object)_right?.Line != (Object)null)
			{
				((Renderer)_right.Line).enabled = flag;
			}
			if (flag)
			{
				Draw(_right);
			}
		}

		private static void PoseTransform(Ray r)
		{
			//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)
			if ((Object)(object)r?.Go == (Object)null)
			{
				return;
			}
			VRRig instance = VRRig.Instance;
			if (!((Object)(object)instance == (Object)null))
			{
				Transform val = (r.Left ? instance.LeftHand : instance.RightHand);
				if ((Object)(object)val != (Object)null)
				{
					r.Go.transform.SetPositionAndRotation(val.position, val.rotation * PointerTilt);
				}
			}
		}

		private static void Draw(Ray r)
		{
			//IL_0034: 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_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: 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_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)
			if (!((Object)(object)r?.Go == (Object)null) && !((Object)(object)r.Line == (Object)null))
			{
				PoseTransform(r);
				Vector3 position = r.Go.transform.position;
				VRPointerInputModule instance = VRPointerInputModule.Instance;
				instance?.RefreshRaycastForRender();
				Vector3 val = position + r.Go.transform.forward * 5f;
				if ((Object)(object)instance != (Object)null && instance.HasHit)
				{
					val = instance.HitPoint;
				}
				r.Line.SetPosition(0, position);
				r.Line.SetPosition(1, val);
			}
		}
	}
	internal sealed class VRPointerInputModule : BaseInputModule
	{
		private const float MaxDistance = 25f;

		private const float ClickForgivenessSeconds = 0.18f;

		private Transform _rayOrigin;

		private Camera _eventCamera;

		private PointerEventData _pointer;

		private GameObject _hover;

		private GameObject _lastValidHover;

		private float _lastValidHoverTime;

		private Plane _pressPlane;

		private Transform _pressReference;

		private Vector3 _pressCameraLocalPosition;

		private Quaternion _pressCameraLocalRotation;

		private Vector3 _pressPointLocal;

		private bool _cameraFrozen;

		private bool _laserActive;

		private bool _lastTrigger;

		private bool _rightHeld;

		internal static VRPointerInputModule Instance { get; private set; }

		internal bool HasHit { get; private set; }

		internal Vector3 HitPoint { get; private set; }

		protected override void Awake()
		{
			((UIBehaviour)this).Awake();
			Instance = this;
		}

		protected override void OnDestroy()
		{
			if ((Object)(object)Instance == (Object)(object)this)
			{
				Instance = null;
			}
			((UIBehaviour)this).OnDestroy();
		}

		protected override void OnEnable()
		{
			((BaseInputModule)this).OnEnable();
			BaseInputModule[] components = ((Component)this).GetComponents<BaseInputModule>();
			foreach (BaseInputModule val in components)
			{
				if ((Object)(object)val != (Object)(object)this)
				{
					((Behaviour)val).enabled = false;
				}
			}
		}

		internal void SetLaserActive(bool active)
		{
			_laserActive = active;
		}

		internal void RefreshRaycastForRender()
		{
			if (!_laserActive || !EnsureSetup())
			{
				HasHit = false;
				return;
			}
			PoseRay();
			UpdatePointerPosition(_lastTrigger);
			VRUIManager.ReassignLaserEventCamera(_eventCamera);
			DoRaycast();
		}

		private bool EnsureSetup()
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Expected O, but got Unknown
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Expected O, but got Unknown
			//IL_00e0: 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_00f2: Expected O, but got Unknown
			if ((Object)(object)_rayOrigin != (Object)null && (Object)(object)_eventCamera != (Object)null && _pointer != null)
			{
				return true;
			}
			GameObject val = new GameObject("VRPointerRayOrigin");
			val.transform.SetParent(((Component)this).transform, false);
			_rayOrigin = val.transform;
			GameObject val2 = new GameObject("VRPointerEventCamera");
			val2.transform.SetParent(_rayOrigin, false);
			_eventCamera = val2.AddComponent<Camera>();
			((Behaviour)_eventCamera).enabled = false;
			_eventCamera.clearFlags = (CameraClearFlags)4;
			_eventCamera.cullingMask = 32;
			_eventCamera.nearClipPlane = 0.01f;
			_eventCamera.farClipPlane = 25f;
			_eventCamera.fieldOfView = 60f;
			_eventCamera.stereoTargetEye = (StereoTargetEyeMask)0;
			_pointer = new PointerEventData(((BaseInputModule)this).eventSystem)
			{
				pointerId = -120
			};
			return true;
		}

		public override void Process()
		{
			if (!EnsureSetup())
			{
				return;
			}
			bool flag = ReadTrigger((XRNode)5, _rightHeld);
			if (!_laserActive)
			{
				if (_lastTrigger)
				{
					ReleasePointer();
				}
				ClearHover();
				HasHit = false;
				_lastTrigger = false;
				_rightHeld = flag;
				return;
			}
			_rightHeld = flag;
			bool flag2 = flag;
			bool num = flag2 && !_lastTrigger;
			bool flag3 = !flag2 && _lastTrigger;
			PoseRay();
			UpdatePointerPosition(flag2);
			VRUIManager.ReassignLaserEventCamera(_eventCamera);
			DoRaycast();
			UpdateHover(flag2);
			if (num && (Object)(object)_hover != (Object)null)
			{
				PressPointer();
			}
			if (flag2)
			{
				DragPointer();
			}
			if (flag3)
			{
				ReleasePointer();
			}
			_lastTrigger = flag2;
		}

		private static bool ReadTrigger(XRNode node, bool wasHeld)
		{
			//IL_0006: 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_000c: 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)
			float num = 0f;
			try
			{
				InputDevice deviceAtXRNode = InputDevices.GetDeviceAtXRNode(node);
				if (((InputDevice)(ref deviceAtXRNode)).isValid)
				{
					((InputDevice)(ref deviceAtXRNode)).TryGetFeatureValue(CommonUsages.trigger, ref num);
				}
			}
			catch
			{
			}
			if (!wasHeld)
			{
				return num >= 0.35f;
			}
			return num >= 0.18f;
		}

		private void PoseRay()
		{
			//IL_0028: 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_0038: 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_0081: Unknown result type (might be due to invalid IL or missing references)
			VRRig instance = VRRig.Instance;
			if ((Object)(object)instance == (Object)null)
			{
				return;
			}
			Transform rightHand = instance.RightHand;
			if (!((Object)(object)rightHand == (Object)null))
			{
				_rayOrigin.SetPositionAndRotation(rightHand.position, rightHand.rotation * VRLaser.PointerTilt);
				if (!_cameraFrozen)
				{
					((Component)_eventCamera).transform.SetParent(_rayOrigin, false);
					((Component)_eventCamera).transform.localPosition = Vector3.zero;
					((Component)_eventCamera).transform.localRotation = Quaternion.identity;
				}
				else
				{
					UpdateFrozenReferenceFrame();
				}
			}
		}

		private void UpdateFrozenReferenceFrame()
		{
			//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_0047: 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_0063: 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_006d: 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_007f: 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)
			if (_cameraFrozen && !((Object)(object)_pressReference == (Object)null) && !((Object)(object)_eventCamera == (Object)null))
			{
				((Component)_eventCamera).transform.SetPositionAndRotation(_pressReference.TransformPoint(_pressCameraLocalPosition), _pressReference.rotation * _pressCameraLocalRotation);
				Vector3 val = _pressReference.TransformPoint(_pressPointLocal);
				_pressPlane = new Plane(-_pressReference.forward, val);
			}
		}

		private void UpdatePointerPosition(bool pressed)
		{
			//IL_00a8: 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_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: 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_002e: 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_0074: 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_004e: 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_0056: 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)
			Vector2 position = default(Vector2);
			if (pressed && _cameraFrozen)
			{
				Ray val = default(Ray);
				((Ray)(ref val))..ctor(_rayOrigin.position, _rayOrigin.forward);
				float num = default(float);
				if (((Plane)(ref _pressPlane)).Raycast(val, ref num) && num <= 25f)
				{
					Vector3 val2 = _eventCamera.WorldToScreenPoint(((Ray)(ref val)).GetPoint(num));
					((Vector2)(ref position))..ctor(val2.x, val2.y);
				}
				else
				{
					position = _pointer.position;
				}
			}
			else
			{
				((Vector2)(ref position))..ctor((float)_eventCamera.pixelWidth * 0.5f, (float)_eventCamera.pixelHeight * 0.5f);
			}
			_pointer.delta = position - _pointer.position;
			_pointer.position = position;
		}

		private void DoRaycast()
		{
			//IL_0030: 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_0063: 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_007a: 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_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: 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_010f: 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)
			((BaseInputModule)this).eventSystem.RaycastAll(_pointer, base.m_RaycastResultCache);
			for (int num = base.m_RaycastResultCache.Count - 1; num >= 0; num--)
			{
				RaycastResult val = base.m_RaycastResultCache[num];
				if (!VRUIManager.IsLaserManaged(((RaycastResult)(ref val)).gameObject))
				{
					base.m_RaycastResultCache.RemoveAt(num);
				}
			}
			RaycastResult pointerCurrentRaycast = BaseInputModule.FindFirstRaycast(base.m_RaycastResultCache);
			base.m_RaycastResultCache.Clear();
			_pointer.pointerCurrentRaycast = pointerCurrentRaycast;
			if ((Object)(object)((RaycastResult)(ref pointerCurrentRaycast)).gameObject == (Object)null)
			{
				HasHit = false;
				return;
			}
			Transform transform = ((RaycastResult)(ref pointerCurrentRaycast)).gameObject.transform;
			Plane val2 = default(Plane);
			((Plane)(ref val2))..ctor(-transform.forward, transform.position);
			Ray val3 = default(Ray);
			((Ray)(ref val3))..ctor(_rayOrigin.position, _rayOrigin.forward);
			float num2 = default(float);
			HasHit = ((Plane)(ref val2)).Raycast(val3, ref num2) && num2 <= 25f;
			HitPoint = (HasHit ? ((Ray)(ref val3)).GetPoint(num2) : transform.position);
		}

		private void UpdateHover(bool pressed)
		{
			//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)
			RaycastResult pointerCurrentRaycast = _pointer.pointerCurrentRaycast;
			GameObject val = ((RaycastResult)(ref pointerCurrentRaycast)).gameObject;
			if (pressed && (Object)(object)_pointer.pointerDrag != (Object)null && (Object)(object)val == (Object)null)
			{
				val = _hover;
			}
			if ((Object)(object)val != (Object)(object)_hover)
			{
				((BaseInputModule)this).HandlePointerExitAndEnter(_pointer, val);
				_hover = val;
			}
			if ((Object)(object)_hover != (Object)null)
			{
				_lastValidHover = _hover;
				_lastValidHoverTime = Time.unscaledTime;
			}
		}

		private void PressPointer()
		{
			//IL_001f: 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_0114: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_011e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0125: Unknown result type (might be due to invalid IL or missing references)
			//IL_012a: Unknown result type (might be due to invalid IL or missing references)
			//IL_013a: Unknown result type (might be due to invalid IL or missing references)
			//IL_013f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0144: Unknown result type (might be due to invalid IL or missing references)
			//IL_015c: 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_0161: Unknown result type (might be due to invalid IL or missing references)
			//IL_0166: Unknown result type (might be due to invalid IL or missing references)
			GameObject hover = _hover;
			_pointer.eligibleForClick = true;
			_pointer.pressPosition = _pointer.position;
			_pointer.pointerPressRaycast = _pointer.pointerCurrentRaycast;
			_pointer.useDragThreshold = true;
			_pointer.button = (InputButton)0;
			GameObject val = ExecuteEvents.ExecuteHierarchy<IPointerDownHandler>(hover, (BaseEventData)(object)_pointer, ExecuteEvents.pointerDownHandler);
			if ((Object)(object)val == (Object)null)
			{
				val = ExecuteEvents.GetEventHandler<IPointerClickHandler>(hover);
			}
			_pointer.pointerPress = val;
			_pointer.rawPointerPress = hover;
			_pointer.clickTime = Time.unscaledTime;
			_pointer.pointerDrag = ExecuteEvents.GetEventHandler<IDragHandler>(hover);
			if ((Object)(object)_pointer.pointerDrag != (Object)null)
			{
				ExecuteEvents.Execute<IInitializePotentialDragHandler>(_pointer.pointerDrag, (BaseEventData)(object)_pointer, ExecuteEvents.initializePotentialDrag);
			}
			Canvas componentInParent = hover.GetComponentInParent<Canvas>();
			Transform val2 = (_pressReference = (((Object)(object)componentInParent != (Object)null) ? ((Component)componentInParent).transform : hover.transform));
			_pressCameraLocalPosition = val2.InverseTransformPoint(((Component)_eventCamera).transform.position);
			_pressCameraLocalRotation = Quaternion.Inverse(val2.rotation) * ((Component)_eventCamera).transform.rotation;
			_pressPointLocal = val2.InverseTransformPoint(HasHit ? HitPoint : val2.position);
			((Component)_eventCamera).transform.SetParent((Transform)null, true);
			_cameraFrozen = true;
			UpdateFrozenReferenceFrame();
			((BaseInputModule)this).eventSystem.SetSelectedGameObject(val, (BaseEventData)(object)_pointer);
		}

		private void DragPointer()
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: 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)
			if ((Object)(object)_pointer.pointerDrag == (Object)null)
			{
				return;
			}
			float num = ((BaseInputModule)this).eventSystem.pixelDragThreshold;
			if (!_pointer.dragging)
			{
				Vector2 val = _pointer.pressPosition - _pointer.position;
				if (((Vector2)(ref val)).sqrMagnitude >= num * num)
				{
					ExecuteEvents.Execute<IBeginDragHandler>(_pointer.pointerDrag, (BaseEventData)(object)_pointer, ExecuteEvents.beginDragHandler);
					_pointer.dragging = true;
				}
			}
			if (_pointer.dragging)
			{
				if ((Object)(object)_pointer.pointerPress != (Object)(object)_pointer.pointerDrag)
				{
					ExecuteEvents.Execute<IPointerUpHandler>(_pointer.pointerPress, (BaseEventData)(object)_pointer, ExecuteEvents.pointerUpHandler);
					_pointer.eligibleForClick = false;
					_pointer.pointerPress = null;
					_pointer.rawPointerPress = null;
				}
				ExecuteEvents.Execute<IDragHandler>(_pointer.pointerDrag, (BaseEventData)(object)_pointer, ExecuteEvents.dragHandler);
			}
		}

		private void ReleasePointer()
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: 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_01a9: Unknown result type (might be due to invalid IL or missing references)
			if (_pointer != null)
			{
				RaycastResult pointerCurrentRaycast = _pointer.pointerCurrentRaycast;
				GameObject gameObject = ((RaycastResult)(ref pointerCurrentRaycast)).gameObject;
				ExecuteEvents.Execute<IPointerUpHandler>(_pointer.pointerPress, (BaseEventData)(object)_pointer, ExecuteEvents.pointerUpHandler);
				GameObject val = gameObject;
				if ((Object)(object)val == (Object)null && Time.unscaledTime - _lastValidHoverTime <= 0.18f)
				{
					val = _lastValidHover;
				}
				GameObject eventHandler = ExecuteEvents.GetEventHandler<IPointerClickHandler>(val);
				if ((Object)(object)_pointer.pointerPress != (Object)null && _pointer.eligibleForClick && (Object)(object)eventHandler == (Object)(object)_pointer.pointerPress)
				{
					ExecuteEvents.Execute<IPointerClickHandler>(_pointer.pointerPress, (BaseEventData)(object)_pointer, ExecuteEvents.pointerClickHandler);
				}
				else if ((Object)(object)_pointer.pointerDrag != (Object)null && _pointer.dragging && (Object)(object)gameObject != (Object)null)
				{
					ExecuteEvents.ExecuteHierarchy<IDropHandler>(gameObject, (BaseEventData)(object)_pointer, ExecuteEvents.dropHandler);
				}
				if (_pointer.dragging)
				{
					ExecuteEvents.Execute<IEndDragHandler>(_pointer.pointerDrag, (BaseEventData)(object)_pointer, ExecuteEvents.endDragHandler);
				}
				_pointer.dragging = false;
				_pointer.eligibleForClick = false;
				_pointer.pointerPress = null;
				_pointer.rawPointerPress = null;
				_pointer.pointerDrag = null;
				if ((Object)(object)_eventCamera != (Object)null && (Object)(object)_rayOrigin != (Object)null)
				{
					((Component)_eventCamera).transform.SetParent(_rayOrigin, false);
					((Component)_eventCamera).transform.localPosition = Vector3.zero;
					((Component)_eventCamera).transform.localRotation = Quaternion.identity;
				}
				_cameraFrozen = false;
				_pressReference = null;
			}
		}

		private void ClearHover()
		{
			if (_pointer != null)
			{
				((BaseInputModule)this).HandlePointerExitAndEnter(_pointer, (GameObject)null);
			}
			_hover = null;
		}
	}
	public class VRSettingsPanel : MonoBehaviour
	{
		private enum RowKind
		{
			Stepper,
			Toggle,
			Slider,
			Button
		}

		private struct SettingRow
		{
			public string Label;

			public RowKind Kind;

			public Func<string> Value;

			public Action OnPrev;

			public Action OnNext;

			public Action OnClick;

			public Func<bool> GetBool;

			public Action<bool> SetBool;

			public Func<float> GetFloat;

			public Action<float> SetFloat;

			public float Min;

			public float Max;

			public bool WholeNumbers;
		}

		private GameObject _pauseEntryButton;

		private GameObject _mainMenuEntryButton;

		private GameObject _buttonTemplate;

		private Image _nativeBackdropStyle;

		private GameObject _nativeToggleTemplate;

		private GameObject _nativeSliderTemplate;

		private bool _templatesScanned;

		private GameObject _page;

		private bool _pageOpen;

		private bool _openedFromPause;

		private GameObject _pauseHolder;

		private GameObject _pauseMainScreen;

		private bool _pauseMainScreenWasActive;

		private Transform _mainCanvasRoot;

		private GameObject _mainMenuPage;

		private GameObject _mainMenuTitle;

		private GameObject _discordButton;

		private bool _mainMenuHidden;

		private readonly List<(GameObject, Func<string>)> _valueRefreshers = new List<(GameObject, Func<string>)>();

		private float _nextProbe;

		private bool _prevBothSticks;

		private bool _wasPaused;

		private bool _wasInMenu;

		public static VRSettingsPanel Instance { get; private set; }

		public static bool IsOpen
		{
			get
			{
				if ((Object)(object)Instance != (Object)null)
				{
					return Instance._pageOpen;
				}
				return false;
			}
		}

		public static void Create()
		{
			//IL_0013: 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_001e: Expected O, but got Unknown
			if (!((Object)(object)Instance != (Object)null))
			{
				GameObject val = new GameObject("HowToFishVR Settings");
				Object.DontDestroyOnLoad((Object)val);
				Instance = val.AddComponent<VRSettingsPanel>();
			}
		}

		private void Update()
		{
			bool flag = false;
			try
			{
				if (Input.GetKeyDown((KeyCode)282))
				{
					flag = true;
				}
			}
			catch
			{
			}
			VRActions instance = VRActions.Instance;
			if (instance != null)
			{
				bool flag2 = instance.SprintButton.IsPressed() && instance.CrouchButton.IsPressed();
				if (flag2 && !_prevBothSticks)
				{
					flag = true;
				}
				_prevBothSticks = flag2;
			}
			if (flag)
			{
				if (_pageOpen)
				{
					Close();
				}
				else
				{
					bool flag3 = false;
					try
					{
						flag3 = MainMenuManager.IsInMenu;
					}
					catch
					{
					}
					bool flag4 = false;
					try
					{
						flag4 = PauseManager.IsPaused;
					}
					catch
					{
					}
					if (flag3)
					{
						Open(fromPause: false);
					}
					else if (flag4)
					{
						Open(fromPause: true);
					}
				}
			}
			Tick();
		}

		private void Tick()
		{
			if (!Plugin.VREnabled)
			{
				return;
			}
			bool flag = IsInMenu();
			bool flag2 = IsPaused() && !flag;
			if (flag2 && !_wasPaused && (Object)(object)_pauseEntryButton == (Object)null)
			{
				TryInjectPause();
			}
			if (flag && !_wasInMenu && (Object)(object)_mainMenuEntryButton == (Object)null)
			{
				TryInjectMainMenu();
			}
			_wasPaused = flag2;
			_wasInMenu = flag;
			if ((Object)(object)_mainMenuEntryButton != (Object)null)
			{
				_mainMenuEntryButton.SetActive(flag && !_pageOpen);
			}
			if ((Object)(object)_pauseEntryButton != (Object)null)
			{
				_pauseEntryButton.SetActive(flag2 && (Object)(object)_pauseMainScreen != (Object)null && _pauseMainScreen.activeSelf && !_pageOpen);
			}
			if (Time.unscaledTime < _nextProbe)
			{
				return;
			}
			_nextProbe = Time.unscaledTime + (((Object)(object)_pauseEntryButton == (Object)null || (Object)(object)_mainMenuEntryButton == (Object)null) ? 0.2f : 1f);
			if ((Object)(object)_mainMenuEntryButton == (Object)null && flag)
			{
				TryInjectMainMenu();
			}
			if ((Object)(object)_pauseEntryButton == (Object)null && flag2)
			{
				TryInjectPause();
			}
			if (_pageOpen)
			{
				if ((Object)(object)_page == (Object)null)
				{
					BuildPage();
				}
				else if (!_page.activeSelf)
				{
					_page.SetActive(true);
				}
				else if ((Object)(object)_page.transform.parent != (Object)null)
				{
					_page.transform.SetAsLastSibling();
				}
			}
			if (_pageOpen && _openedFromPause && !flag2)
			{
				Close();
			}
			else if (_pageOpen && !_openedFromPause && !flag)
			{
				Close();
			}
		}

		private static bool IsInMenu()
		{
			try
			{
				return MainMenuManager.IsInMenu;
			}
			catch
			{
				return false;
			}
		}

		private static bool IsPaused()
		{
			try
			{
				return PauseManager.IsPaused;
			}
			catch
			{
				return false;
			}
		}

		private void TryInjectPause()
		{
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Expected O, but got Unknown
			try
			{
				PauseManager val = Object.FindObjectOfType<PauseManager>(true);
				if ((Object)(object)val == (Object)null || (Object)(object)val._pauseHolder == (Object)null || (Object)(object)val._mainScreen == (Object)null)
				{
					return;
				}
				_pauseHolder = val._pauseHolder;
				_pauseMainScreen = val._mainScreen;
				TextMeshProUGUI val2 = FindMenuText(_pauseMainScreen.transform, "Options");
				if ((Object)(object)val2 == (Object)null)
				{
					return;
				}
				Button componentInParent = ((Component)val2).GetComponentInParent<Button>(true);
				if (!((Object)(object)componentInParent == (Object)null))
				{
					if ((Object)(object)_buttonTemplate == (Object)null)
					{
						_buttonTemplate = ((Component)componentInParent).gameObject;
					}
					DiscoverBackdropStyle(val._pauseHolder.transform);
					DiscoverNativeTemplates();
					RemoveStaleButtons(((Component)componentInParent).transform.parent);
					_pauseEntryButton = CreateStyledButton(((Component)componentInParent).gameObject, ((Component)componentInParent).transform.parent, "VR Settings", new UnityAction(OpenFromPause));
					InsertAfter(((Component)componentInParent).GetComponent<RectTransform>(), _pauseEntryButton.GetComponent<RectTransform>());
					_pauseEntryButton.SetActive(false);
				}
			}
			catch
			{
			}
		}

		private void TryInjectMainMenu()
		{
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Expected O, but got Unknown
			try
			{
				CanvasManager val = Object.FindObjectOfType<CanvasManager>(true);
				if ((Object)(object)val == (Object)null || (Object)(object)val._mainMenuCanvas == (Object)null)
				{
					return;
				}
				_mainCanvasRoot = ((Component)val._mainMenuCanvas).transform;
				if (val._allMainMenuButtons != null && val._allMainMenuButtons.Count > 0)
				{
					_mainMenuPage = val._allMainMenuButtons[0];
				}
				_mainMenuTitle = val._howToFishTitle;
				_discordButton = val._discordButton;
				TextMeshProUGUI val2 = FindMenuText(_mainCanvasRoot, "Options");
				if (!((Object)(object)val2 == (Object)null))
				{
					Button componentInParent = ((Component)val2).GetComponentInParent<Button>(true);
					if (!((Object)(object)componentInParent == (Object)null))
					{
						_buttonTemplate = ((Component)componentInParent).gameObject;
						DiscoverBackdropStyle(_mainCanvasRoot);
						DiscoverNativeTemplates();
						RemoveStaleButtons(((Component)componentInParent).transform.parent);
						_mainMenuEntryButton = CreateStyledButton(((Component)componentInParent).gameObject, ((Component)componentInParent).transform.parent, "VR Settings", new UnityAction(OpenFromMainMenu));
						InsertAfter(((Component)componentInParent).GetComponent<RectTransform>(), _mainMenuEntryButton.GetComponent<RectTransform>());
					}
				}
			}
			catch
			{
			}
		}

		private void RediscoverTemplate()
		{
			if ((Object)(object)_buttonTemplate != (Object)null)
			{
				return;
			}
			try
			{
				GameObject val = null;
				if (_openedFromPause && (Object)(object)_pauseMainScreen != (Object)null)
				{
					TextMeshProUGUI val2 = FindMenuText(_pauseMainScreen.transform, "Options");
					if ((Object)(object)val2 != (Object)null)
					{
						Button componentInParent = ((Component)val2).GetComponentInParent<Button>(true);
						if ((Object)(object)componentInParent != (Object)null)
						{
							val = ((Component)componentInParent).gameObject;
						}
					}
				}
				if ((Object)(object)val == (Object)null && (Object)(object)_mainCanvasRoot != (Object)null)
				{
					TextMeshProUGUI val3 = FindMenuText(_mainCanvasRoot, "Options");
					if ((Object)(object)val3 != (Object)null)
					{
						Button componentInParent2 = ((Component)val3).GetComponentInParent<Button>(true);
						if ((Object)(object)componentInParent2 != (Object)null)
						{
							val = ((Component)componentInParent2).gameObject;
						}
					}
				}
				if ((Object)(object)val == (Object)null)
				{
					TextMeshProUGUI[] array = Object.FindObjectsOfType<TextMeshProUGUI>(true);
					foreach (TextMeshProUGUI val4 in array)
					{
						if (!((Object)(object)val4 == (Object)null) && string.Equals((((TMP_Text)val4).text ?? "").Trim(), "Options", StringComparison.OrdinalIgnoreCase))
						{
							Button componentInParent3 = ((Component)val4).GetComponentInParent<Button>(true);
							if ((Object)(object)componentInParent3 != (Object)null)
							{
								val = ((Component)componentInParent3).gameObject;
								break;
							}
						}
					}
				}
				if ((Object)(object)val != (Object)null)
				{
					_buttonTemplate = val;
				}
			}
			catch
			{
			}
		}

		private static void RemoveStaleButtons(Transform parent)
		{
			if ((Object)(object)parent == (Object)null)
			{
				return;
			}
			try
			{
				for (int num = parent.childCount - 1; num >= 0; num--)
				{
					Transform child = parent.GetChild(num);
					if ((Object)(object)child != (Object)null && ((Object)child).name != null && ((Object)child).name.StartsWith("VRSettingsButton_", StringComparison.Ordinal))
					{
						Object.Destroy((Object)(object)((Component)child).gameObject);
					}
				}
			}
			catch
			{
			}
		}

		private void OpenFromPause()
		{
			Open(fromPause: true);
		}

		private void OpenFromMainMenu()
		{
			Open(fromPause: false);
		}

		private void Open(bool fromPause)
		{
			_pageOpen = true;
			_openedFromPause = fromPause;
			if (fromPause)
			{
				if ((Object)(object)_pauseEntryButton != (Object)null)
				{
					_pauseEntryButton.SetActive(false);
				}
				if ((Object)(object)_pauseMainScreen != (Object)null)
				{
					_pauseMainScreenWasActive = _pauseMainScreen.activeSelf;
					_pauseMainScreen.SetActive(false);
				}
			}
			else
			{
				if ((Object)(object)_mainMenuEntryButton != (Object)null)
				{
					_mainMenuEntryButton.SetActive(false);
				}
				HideMainMenu();
			}
			BuildPage();
		}

		private void Close()
		{
			_pageOpen = false;
			if ((Object)(object)_page != (Object)null)
			{
				Object.Destroy((Object)(object)_page);
			}
			_page = null;
			_valueRefreshers.Clear();
			if (_openedFromPause)
			{
				if ((Object)(object)_pauseMainScreen != (Object)null && IsPaused() && !IsInMenu())
				{
					_pauseMainScreen.SetActive(_pauseMainScreenWasActive);
				}
				if ((Object)(object)_pauseEntryButton != (Object)null && IsPaused() && !IsInMenu())
				{
					_pauseEntryButton.SetActive(true);
				}
			}
			else
			{
				RestoreMainMenu();
				if ((Object)(object)_mainMenuEntryButton != (Object)null && IsInMenu())
				{
					_mainMenuEntryButton.SetActive(true);
				}
			}
			_openedFromPause = false;
		}

		private void HideMainMenu()
		{
			_mainMenuHidden = true;
			if ((Object)(object)_mainMenuPage != (Object)null)
			{
				_mainMenuPage.SetActive(false);
			}
			if ((Object)(object)_mainMenuTitle != (Object)null)
			{
				_mainMenuTitle.SetActive(false);
			}
			if ((Object)(object)_discordButton != (Object)null)
			{
				_discordButton.SetActive(false);
			}
		}

		private void RestoreMainMenu()
		{
			if (_mainMenuHidden)
			{
				if ((Object)(object)_mainMenuPage != (Object)null)
				{
					_mainMenuPage.SetActive(true);
				}
				if ((Object)(object)_mainMenuTitle != (Object)null)
				{
					_mainMenuTitle.SetActive(true);
				}
				if ((Object)(object)_discordButton != (Object)null)
				{
					_discordButton.SetActive(true);
				}
				_mainMenuHidden = false;
			}
		}

		private void BuildPage()
		{
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Expected O, but got Unknown
			//IL_010b: 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_0118: Unknown result type (might be due to invalid IL or missing references)
			//IL_011e: Expected O, but got Unknown
			//IL_0143: 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_0196: Unknown result type (might be due to invalid IL or missing references)
			//IL_019b: 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_01c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d2: Expected O, but got Unknown
			//IL_01ef: 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_020f: 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_0289: Unknown result type (might be due to invalid IL or missing references)
			//IL_0293: Expected O, but got Unknown
			//IL_02a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bc: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_page != (Object)null)
			{
				Object.Destroy((Object)(object)_page);
			}
			Transform val = null;
			if (_openedFromPause && (Object)(object)_pauseHolder != (Object)null)
			{
				val = _pauseHolder.transform;
			}
			else if ((Object)(object)_mainCanvasRoot != (Object)null)
			{
				val = _mainCanvasRoot;
			}
			else if ((Object)(object)_mainMenuEntryButton != (Object)null)
			{
				val = _mainMenuEntryButton.transform.parent;
			}
			else if ((Object)(object)_pauseEntryButton != (Object)null)
			{
				val = _pauseEntryButton.transform.parent;
			}
			if ((Object)(object)val == (Object)null)
			{
				_pageOpen = false;
				return;
			}
			RediscoverTemplate();
			if ((Object)(object)_buttonTemplate == (Object)null)
			{
				_pageOpen = false;
				return;
			}
			_page = new GameObject("HowToFishVR SettingsPage", new Type[3]
			{
				typeof(RectTransform),
				typeof(CanvasGroup),
				typeof(Image)
			});
			RectTransform val2 = (RectTransform)_page.transform;
			((Transform)val2).SetParent(val, false);
			Stretch(val2);
			((Transform)val2).SetAsLastSibling();
			Image component = _page.GetComponent<Image>();
			((Graphic)component).color = new Color(0f, 0f, 0f, 0.78f);
			((Graphic)component).raycastTarget = true;
			SetRect(((TMP_Text)CreateText("Title", _page.transform, "VR Settings", 58f, (TextAlignmentOptions)257)).rectTransform, new Vector2(0.06f, 0.9f), new Vector2(0.94f, 0.985f), Vector2.zero, Vector2.zero);
			RectTransform val3 = (RectTransform)new GameObject("Rows", new Type[1] { typeof(RectTransform) }).transform;
			((Transform)val3).SetParent(_page.transform, false);
			val3.anchorMin = new Vector2(0.06f, 0.07f);
			val3.anchorMax = new Vector2(0.94f, 0.885f);
			val3.offsetMin = Vector2.zero;
			val3.offsetMax = Vector2.zero;
			float num = 4f;
			foreach (SettingRow item in BuildSettingsList())
			{
				CreateSettingRow(val3, item, num);
				num += 48f;
			}
			GameObject obj = CreateStyledButton(_buttonTemplate, _page.transform, "Back", new UnityAction(Close));
			SetRect(obj.GetComponent<RectTransform>(), new Vector2(0.06f, 0.015f), new Vector2(0.25f, 0.062f), Vector2.zero, Vector2.zero);
			SetButtonText(obj, "Back");
		}

		private void CreateSettingRow(RectTransform parent, SettingRow row, float y)
		{
			//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_004c: Expected O, but got Unknown
			//IL_005f: 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_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: 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_015a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0164: Expected O, but got Unknown
			//IL_0174: Unknown result type (might be due to invalid IL or missing references)
			//IL_0179: Unknown result type (might be due to invalid IL or missing references)
			//IL_017e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0183: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bb: Expected O, but got Unknown
			//IL_01cb: 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_01df: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0216: Unknown result type (might be due to invalid IL or missing references)
			//IL_0220: Expected O, but got Unknown
			//IL_0231: Unknown result type (might be due to invalid IL or missing references)
			//IL_0240: Unknown result type (might be due to invalid IL or missing references)
			//IL_0245: Unknown result type (might be due to invalid IL or missing references)
			//IL_024a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0299: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a3: Expected O, but got Unknown
			//IL_02b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c7: 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)
			RectTransform val = (RectTransform)new GameObject("Row_" + row.Label, new Type[1] { typeof(RectTransform) }).transform;
			((Transform)val).SetParent((Transform)(object)parent, false);
			val.anchorMin = new Vector2(0f, 1f);
			val.anchorMax = new Vector2(1f, 1f);
			val.pivot = new Vector2(0.5f, 1f);
			val.anchoredPosition = new Vector2(0f, 0f - y);
			val.sizeDelta = new Vector2(0f, 44f);
			SetRect(((TMP_Text)CreateText("Label", (Transform)(object)val, row.Label, 24f, (TextAlignmentOptions)513)).rectTransform, Vector2.zero, new Vector2(0.5f, 1f), Vector2.zero, Vector2.zero);
			switch (row.Kind)
			{
			case RowKind.Toggle:
				CreateToggleControl(val, row);
				return;
			case RowKind.Slider:
				CreateSliderControl(val, row);
				return;
			case RowKind.Button:
			{
				GameObject obj = CreateStyledButton(_buttonTemplate, (Transform)(object)val, row.Label, (UnityAction)delegate
				{
					row.OnClick();
				});
				SetRect(obj.GetComponent<RectTransform>(), new Vector2(0.52f, 0f), Vector2.one, Vector2.zero, Vector2.zero);
				SetButtonText(obj, row.Label);
				return;
			}
			}
			GameObject obj2 = CreateStyledButton(_buttonTemplate, (Transform)(object)val, "<", (UnityAction)delegate
			{
				row.OnPrev();
				RefreshValues();
			});
			SetRect(obj2.GetComponent<RectTransform>(), new Vector2(0.52f, 0.02f), new Vector2(0.6f, 0.98f), Vector2.zero, Vector2.zero);
			SetButtonText(obj2, "<");
			GameObject val2 = CreateStyledButton(_buttonTemplate, (Transform)(object)val, row.Value(), (UnityAction)delegate
			{
				row.OnNext();
				RefreshValues();
			});
			SetRect(val2.GetComponent<RectTransform>(), new Vector2(0.61f, 0.02f), new Vector2(0.88f, 0.98f), Vector2.zero, Vector2.zero);
			SetButtonText(val2, row.Value());
			_valueRefreshers.Add((val2, row.Value));
			GameObject obj3 = CreateStyledButton(_buttonTemplate, (Transform)(object)val, ">", (UnityAction)delegate
			{
				row.OnNext();
				RefreshValues();
			});
			SetRect(obj3.GetComponent<RectTransform>(), new Vector2(0.89f, 0.02f), new Vector2(0.97f, 0.98f), Vector2.zero, Vector2.zero);
			SetButtonText(obj3, ">");
		}

		private void CreateToggleControl(RectTransform rt, SettingRow row)
		{
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Expected O, but got Unknown
			//IL_005e: 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_0068: 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_0137: Unknown result type (might be due to invalid IL or missing references)
			//IL_0146: Unknown result type (might be due to invalid IL or missing references)
			//IL_014b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0150: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Expected O, but got Unknown
			if ((Object)(object)_nativeToggleTemplate == (Object)null)
			{
				GameObject val = CreateStyledButton(_buttonTemplate, (Transform)(object)rt, row.Value(), (UnityAction)delegate
				{
					row.OnNext();
					RefreshValues();
				});
				SetRect(val.GetComponent<RectTransform>(), new Vector2(0.52f, 0f), Vector2.one, Vector2.zero, Vector2.zero);
				SetButtonText(val, row.Value());
				_valueRefreshers.Add((val, row.Value));
				return;
			}
			GameObject obj = Object.Instantiate<GameObject>(_nativeToggleTemplate, (Transform)(object)rt, false);
			((Object)obj).name = "VRSettingsToggle_" + row.Label;
			obj.SetActive(false);
			DisableLocalization(obj);
			Toggle component = obj.GetComponent<Toggle>();
			if ((Object)(object)component != (Object)null)
			{
				component.onValueChanged = new ToggleEvent();
				component.isOn = row.GetBool();
				((UnityEvent<bool>)(object)component.onValueChanged).AddListener((UnityAction<bool>)delegate(bool v)
				{
					row.SetBool(v);
				});
			}
			SetRect(obj.GetComponent<RectTransform>(), new Vector2(0.52f, 0.04f), new Vector2(0.7f, 0.96f), Vector2.zero, Vector2.zero);
			obj.SetActive(true);
		}

		private void CreateSliderControl(RectTransform rt, SettingRow row)
		{
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Expected O, but got Unknown
			//IL_0051: 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_0065: 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_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Expected O, but got Unknown
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Expected O, but got Unknown
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: 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_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_020b: 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_025c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0261: Unknown result type (might be due to invalid IL or missing references)
			//IL_0266: Unknown result type (might be due to invalid IL or missing references)
			//IL_026b: 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_018c: Expected O, but got Unknown
			if ((Object)(object)_nativeSliderTemplate == (Object)null)
			{
				SetRect(CreateStyledButton(_buttonTemplate, (Transform)(object)rt, "<", (UnityAction)delegate
				{
					row.OnPrev();
					RefreshValues();
				}).GetComponent<RectTransform>(), new Vector2(0.52f, 0.02f), new Vector2(0.6f, 0.98f), Vector2.zero, Vector2.zero);
				GameObject val = CreateStyledButton(_buttonTemplate, (Transform)(object)rt, row.Value(), (UnityAction)delegate
				{
					row.OnNext();
					RefreshValues();
				});
				SetRect(val.GetComponent<RectTransform>(), new Vector2(0.61f, 0.02f), new Vector2(0.88f, 0.98f), Vector2.zero, Vector2.zero);
				SetRect(CreateStyledButton(_buttonTemplate, (Transform)(object)rt, ">", (UnityAction)delegate
				{
					row.OnNext();
					RefreshValues();
				}).GetComponent<RectTransform>(), new Vector2(0.89f, 0.02f), new Vector2(0.97f, 0.98f), Vector2.zero, Vector2.zero);
				_valueRefreshers.Add((val, row.Value));
				return;
			}
			GameObject obj = Object.Instantiate<GameObject>(_nativeSliderTemplate, (Transform)(object)rt, false);
			((Object)obj).name = "VRSettingsSlider_" + row.Label;
			obj.SetActive(false);
			DisableLocalization(obj);
			Slider component = obj.GetComponent<Slider>();
			if ((Object)(object)component != (Object)null)
			{
				component.onValueChanged = new SliderEvent();
				component.minValue = row.Min;
				component.maxValue = row.Max;
				component.wholeNumbers = row.WholeNumbers;
				component.value = row.GetFloat();
				((UnityEvent<float>)(object)component.onValueChanged).AddListener((UnityAction<float>)delegate(float v)
				{
					row.SetFloat(v);
				});
			}
			SetRect(obj.GetComponent<RectTransform>(), new Vector2(0.52f, 0.2f), new Vector2(0.82f, 0.8f), Vector2.zero, Vector2.zero);
			obj.SetActive(true);
			TextMeshProUGUI val2 = CreateText("Value", (Transform)(object)rt, row.Value(), 22f, (TextAlignmentOptions)516);
			SetRect(((TMP_Text)val2).rectTransform, new Vector2(0.84f, 0f), Vector2.one, Vector2.zero, Vector2.zero);
			_valueRefreshers.Add((((Component)val2).gameObject, row.Value));
		}

		private void RefreshValues()
		{
			foreach (var (val, func) in _valueRefreshers)
			{
				if ((Object)(object)val != (Object)null)
				{
					SetButtonText(val, func());
				}
			}
		}

		private List<SettingRow> BuildSettingsList()
		{
			return new List<SettingRow>
			{
				Stepper("Body", () => (VRConfig.BodyMode.Value != BodyMode.FullBodyIK) ? "Hands Only" : "Full Body", delegate
				{
					VRConfig.BodyMode.Value = NextEnum(VRConfig.BodyMode.Value);
					HowToFishBody.ApplyBodyMode();
				}),
				Stepper("Turning", () => VRConfig.Turning.Value.ToString(), delegate
				{
					VRConfig.Turning.Value = NextEnum(VRConfig.Turning.Value);
				}),
				Slider("Snap Angle", () => VRConfig.SnapTurnAngle.Value + "°", 15f, 90f, whole: true, () => VRConfig.SnapTurnAngle.Value, delegate(float v)
				{
					VRConfig.SnapTurnAngle.Value = Mathf.RoundToInt(v);
				}),
				Slider("Smooth Speed", () => VRConfig.SmoothTurnSpeed.Value.ToString("F0") + "°/s", 30f, 360f, whole: false, () => VRConfig.SmoothTurnSpeed.Value, delegate(float v)
				{
					VRConfig.SmoothTurnSpeed.Value = v;
				}),
				Toggle("Roomscale Movement", () => VRConfig.RoomscaleMovement.Value, delegate(bool v)
				{
					VRConfig.RoomscaleMovement.Value = v;
				}),
				Stepper("Sprint Mode", () => VRConfig.SprintMode.Value.ToString(), delegate
				{
					VRConfig.SprintMode.Value = NextEnum(VRConfig.SprintMode.Value);
				}),
				Stepper("Crouch Mode", () => VRConfig.CrouchMode.Value.ToString(), delegate
				{
					VRConfig.CrouchMode.Value = NextEnum(VRConfig.CrouchMode.Value);
				}),
				Slider("HUD Scale", () => VRConfig.HudScale.Value.ToString("0.00"), 0.5f, 2f, whole: false, () => VRConfig.HudScale.Value, delegate(float v)
				{
					VRConfig.HudScale.Value = v;
				}),
				Stepper("Death View", () => (VRConfig.DeathView.Value != DeathView.FirstPerson) ? "Third Person" : "First Person", delegate
				{
					VRConfig.DeathView.Value = NextEnum(VRConfig.DeathView.Value);
				}),
				ButtonRow("Calibrate (F3 only)", delegate
				{
					try
					{
						VRCalibration.Instance?.Begin();
					}
					catch
					{
					}
				}),
				ButtonRow("Close", Close)
			};
		}

		private static SettingRow Stepper(string label, Func<string> value, Action change)
		{
			return new SettingRow
			{
				Label = label,
				Kind = RowKind.Stepper,
				Value = value,
				OnPrev = change,
				OnNext = change
			};
		}

		private static SettingRow Toggle(string label, Func<bool> get, Action<bool> set)
		{
			return new SettingRow
			{
				Label = label,
				Kind = RowKind.Toggle,
				GetBool = get,
				SetBool = set,
				Value = () => OnOff(get()),
				OnNext = delegate
				{
					set(!get());
				}
			};
		}

		private static SettingRow Slider(string label, Func<string> value, float min, float max, bool whole, Func<float> get, Action<float> set)
		{
			return new SettingRow
			{
				Label = label,
				Kind = RowKind.Slider,
				Value = value,
				Min = min,
				Max = max,
				WholeNumbers = whole,
				GetFloat = get,
				SetFloat = set
			};
		}

		private static SettingRow ButtonRow(string label, Action onClick)
		{
			return new SettingRow
			{
				Label = label,
				Kind = RowKind.Button,
				OnClick = onClick
			};
		}

		private void DiscoverNativeTemplates()
		{
			if (_templatesScanned)
			{
				return;
			}
			_templatesScanned = true;
			try
			{
				if ((Object)(object)_nativeToggleTemplate == (Object)null)
				{
					Toggle[] array = Object.FindObjectsOfType<Toggle>(true);
					foreach (Toggle val in array)
					{
						if (!((Object)(object)val == (Object)null) && !((Object)val).name.StartsWith("VRSettings", StringComparison.Ordinal) && !((Object)((Component)val).transform.root).name.StartsWith("HowToFishVR", StringComparison.Ordinal))
						{
							_nativeToggleTemplate = ((Component)val).gameObject;
							break;
						}
					}
				}
				if (!((Object)(object)_nativeSliderTemplate == (Object)null))
				{
					return;
				}
				Slider[] array2 = Object.FindObjectsOfType<Slider>(true);
				foreach (Slider val2 in array2)
				{
					if (!((Object)(object)val2 == (Object)null) && !((Object)val2).name.StartsWith("VRSettings", StringComparison.Ordinal) && !((Object)((Component)val2).transform.root).name.StartsWith("HowToFishVR", StringComparison.Ordinal))
					{
						_nativeSliderTemplate = ((Component)val2).gameObject;
						break;
					}
				}
			}
			catch
			{
			}
		}

		private static GameObject CreateStyledButton(GameObject template, Transform parent, string text, UnityAction action)
		{
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Expected O, but got Unknown
			//IL_006d: 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)
			if ((Object)(object)template == (Object)null)
			{
				throw new InvalidOperationException("No native button template (the game's Options button was not found).");
			}
			GameObject obj = Object.Instantiate<GameObject>(template, parent, false);
			((Object)obj).name = "VRSettingsButton_" + text;
			obj.SetActive(false);
			DisableLocalization(obj);
			Button component = obj.GetComponent<Button>();
			if ((Object)(object)component == (Object)null)
			{
				throw new InvalidOperationException("Native Options template has no Button component.");
			}
			component.onClick = new ButtonClickedEvent();
			((UnityEvent)component.onClick).AddListener(action);
			Navigation navigation = default(Navigation);
			((Navigation)(ref navigation)).mode = (Mode)0;
			((Selectable)component).navigation = navigation;
			UIButton component2 = obj.GetComponent<UIButton>();
			if ((Object)(object)component2 != (Object)null)
			{
				component2._selectOnSubmit = null;
			}
			SetButtonText(obj, text);
			obj.SetActive(true);
			return obj;
		}

		private static void DisableLocalization(GameObject clone)
		{
			Component[] componentsInChildren = clone.GetComponentsInChildren<Component>(true);
			foreach (Component val in componentsInChildren)
			{
				if ((Object)(object)val == (Object)null)
				{
					continue;
				}
				Type type = ((object)val).GetType();
				if ((type.FullName ?? type.Name).IndexOf("Localiz", StringComparison.OrdinalIgnoreCase) >= 0)
				{
					Behaviour val2 = (Behaviour)(object)((val is Behaviour) ? val : null);
					if ((Object)(object)val2 != (Object)null)
					{
						val2.enabled = false;
					}
				}
			}
		}

		private static void SetButtonText(GameObject button, string value)
		{
			if (!((Object)(object)button == (Object)null))
			{
				TextMeshProUGUI componentInChildren = button.GetComponentInChildren<TextMeshProUGUI>(true);
				if ((Object)(object)componentInChildren != (Object)null)
				{
					((TMP_Text)componentInChildren).text = value;
				}
			}
		}

		private static TextMeshProUGUI FindMenuText(Transform root, string value)
		{
			if ((Object)(object)root == (Object)null)
			{
				return null;
			}
			TextMeshProUGUI[] componentsInChildren = ((Component)root).GetComponentsInChildren<TextMeshProUGUI>(true);
			foreach (TextMeshProUGUI val in componentsInChildren)
			{
				if ((Object)(object)val != (Object)null && string.Equals((((TMP_Text)val).text ?? "").Trim(), value, StringComparison.OrdinalIgnoreCase))
				{
					return val;
				}
			}
			return null;
		}

		private static void InsertAfter(RectTransform source, RectTransform clone)
		{
			//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_0055: 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_0068: 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_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: 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)
			((Transform)clone).SetSiblingIndex(((Transform)source).GetSiblingIndex() + 1);
			if ((Object)(object)((Transform)source).parent != (Object)null && (Object)(object)((Component)((Transform)source).parent).GetComponent<LayoutGroup>() != (Object)null)
			{
				return;
			}
			Rect rect = source.rect;
			float num = Math.Max(44f, Math.Abs(((Rect)(ref rect)).height) * 1.12f);
			Vector2 anchoredPosition = source.anchoredPosition;
			anchoredPosition.y -= num;
			clone.anchoredPosition = anchoredPosition;
			if ((Object)(object)((Transform)source).parent == (Object)null)
			{
				return;
			}
			RectTransform[] componentsInChildren = ((Component)((Transform)source).parent).GetComponentsInChildren<RectTransform>(true);
			foreach (RectTransform val in componentsInChildren)
			{
				if (!((Object)(object)val == (Object)null) && (Object)(object)((Transform)val).parent == (Object)(object)((Transform)source).parent && (Object)(object)val != (Object)(object)source && (Object)(object)val != (Object)(object)clone && val.anchoredPosition.y < source.anchoredPosition.y)
				{
					Vector2 anchoredPosition2 = val.anchoredPosition;
					anchoredPosition2.y -= num;
					val.anchoredPosition = anchoredPosition2;
				}
			}
		}

		private TextMeshProUGUI CreateText(string name, Transform parent, string value, float size, TextAlignmentOptions alignment)
		{
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: 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_00b7: Unknown result type (might be due to invalid IL or missing references)
			TextMeshProUGUI val = null;
			if ((Object)(object)_buttonTemplate != (Object)null)
			{
				val = _buttonTemplate.GetComponentInChildren<TextMeshProUGUI>(true);
			}
			GameObject val2 = new GameObject(name, new Type[3]
			{
				typeof(RectTransform),
				typeof(CanvasRenderer),
				typeof(TextMeshProUGUI)
			});
			val2.transform.SetParent(parent, false);
			TextMeshProUGUI component = val2.GetComponent<TextMeshProUGUI>();
			((TMP_Text)component).text = value;
			((TMP_Text)component).fontSize = size;
			((TMP_Text)component).alignment = alignment;
			((TMP_Text)component).enableWordWrapping = true;
			((Graphic)component).raycastTarget = false;
			if ((Object)(object)val != (Object)null)
			{
				((TMP_Text)component).font = ((TMP_Text)val).font;
				((TMP_Text)component).fontSharedMaterial = ((TMP_Text)val).fontSharedMaterial;
				((Graphic)component).color = ((Graphic)val).color;
				((TMP_Text)component).outlineColor = ((TMP_Text)val).outlineColor;
				((TMP_Text)component).outlineWidth = ((TMP_Text)val).outlineWidth;
			}
			return component;
		}

		private void DiscoverBackdropStyle(Transform root)
		{
			//IL_0055: 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_0091: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)root == (Object)null || (Object)(object)_nativeBackdropStyle != (Object)null)
			{
				return;
			}
			Image nativeBackdropStyle = null;
			float num = 0f;
			Image[] componentsInChildren = ((Component)root).GetComponentsInChildren<Image>(true);
			foreach (Image val in componentsInChildren)
			{
				if ((Object)(object)val == (Object)null || (Object)(object)((Component)val).GetComponentInParent<Button>(true) != (Object)null)
				{
					continue;
				}
				Rect rect = ((Graphic)val).rectTransform.rect;
				float num2 = Mathf.Abs(((Rect)(ref rect)).width);
				float num3 = Mathf.Abs(((Rect)(ref rect)).height);
				if (!(num2 < 400f) && !(num3 < 280f))
				{
					float num4 = num2 * num3 + ((Graphic)val).color.a * 10000f;
					if (num4 > num)
					{
						num = num4;
						nativeBackdropStyle = val;
					}
				}
			}
			_nativeBackdropStyle = nativeBackdropStyle;
		}

		private static void CopyImageStyle(Image source, Image target)
		{
			//IL_0039: 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)
			if (!((Object)(object)source == (Object)null) && !((Object)(object)target == (Object)null))
			{
				target.sprite = source.sprite;
				target.overrideSprite = source.overrideSprite;
				((Graphic)target).material = ((Graphic)source).material;
				((Graphic)target).color = ((Graphic)source).color;
				target.type = source.type;
				target.preserveAspect = source.preserveAspect;
				target.fillCenter = source.fillCenter;
			}
		}

		private static void Stretch(RectTransform rect)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: 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)
			rect.anchorMin = Vector2.zero;
			rect.anchorMax = Vector2.one;
			rect.offsetMin = Vector2.zero;
			rect.offsetMax = Vector2.zero;
		}

		private static void SetRect(RectTransform rect, Vector2 min, Vector2 max, Vector2 offsetMin, Vector2 offsetMax)
		{
			//IL_0001: 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_000f: 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)
			rect.anchorMin = min;
			rect.anchorMax = max;
			rect.offsetMin = offsetMin;
			rect.offsetMax = offsetMax;
		}

		private static string OnOff(bool b)
		{
			if (!b)
			{
				return "Off";
			}
			return "On";
		}

		private static T NextEnum<T>(T cur) where T : Enum
		{
			T[] array = (T[])Enum.GetValues(typeof(T));
			int num = Array.IndexOf(array, cur);
			return array[(num + 1) % array.Length];
		}

		private static int NextIn(int[] set, int cur)
		{
			for (int i = 0; i < set.Length; i++)
			{
				if (set[i] == cur)
				{
					return set[(i + 1) % set.Length];
				}
			}
			return set[set.Length / 2];
		}

		private static float NextIn(float[] set, float cur)
		{
			for (int i = 0; i < set.Length; i++)
			{
				if (Mathf.Approximately(set[i], cur))
				{
					return set[(i + 1) % set.Length];
				}
			}
			return set[set.Length / 2];
		}
	}
	public class VRUIManager : MonoBehaviour
	{
		private const float Distance = 2f;

		private const float Width = 2.2f;

		private const float DeathDistance = 1.5f;

		private const float DeathWidth = 3f;

		private static readonly HashSet<string> Whitelist = new HashSet<string>
		{
			"MainCanvas", "BossCanvas", "ThinkingCanvas", "NPCCanvas", "PermaCanvas", "ChatCanvas", "SkipCanvas", "MainMenuCanvas", "PauseCanvas", "EndGameCanvas",
			"FXCanvas", "UnderwaterCanvas", "DeathCanvas", "ItemDotsCanvas"
		};

		private static readonly HashSet<string> Overlays = new HashSet<string> { "FXCanvas", "UnderwaterCanvas" };

		private static readonly HashSet<string> HeadFollowMenus = new HashSet<string> { "MainMenuCanvas", "ChatCanvas", "SkipCanvas", "ThinkingCanvas", "NPCCanvas", "EndGameCanvas" };

		private static readonly HashSet<Canvas> LaserManagedCanvases = new HashSet<Canvas>();

		private static Canvas _priceAnchor;

		private static Canvas _caughtFishPanel;

		private static readonly HashSet<string> WorldAnchored = new HashSet<string> { "ItemDotsCanvas" };

		private static readonly string[] BackdropNameHints = new string[7] { "background", "backdrop", "bkg", "fade", "loading", "splash", "frame" };

		private readonly List<Canvas> _menus = new List<Canvas>();

		private readonly List<Canvas> _hudPanels = new List<Canvas>();

		private readonly List<Canvas> _overlays = new List<Canvas>();

		private readonly HashSet<Canvas> _deathOverlays = new HashSet<Canvas>();

		private readonly HashSet<int> _activeMenus = new HashSet<int>();

		private Canvas _deathPanel;

		private DeathUI _deathPanelOwner;

		private float _rescan;

		private float _transitionScanUntil = 3f;

		public static VRUIManager Instance { get; private set; }

		public static Canvas GetPriceAnchor(Camera cam)
		{
			//IL_0015: 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)
			//IL_0020: Expected O, but got Unknown
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: 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_0053: 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_0088: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_priceAnchor == (Object)null)
			{
				GameObject val = new GameObject("HowToFishVR PriceAnchor");
				Object.DontDestroyOnLoad((Object)val);
				val.layer = 5;
				_priceAnchor = val.AddComponent<Canvas>();
				_priceAnchor.renderMode = (RenderMode)2;
				_priceAnchor.sortingOrder = 50;
				RectTransform val2 = (RectTransform)val.transform;
				val2.sizeDelta = new Vector2(1920f, 1080f);
				float num = 2.2f * VRConfig.HudScale.Value / 1920f * 1.5f;
				((Transform)val2).localScale = new Vector3(num, num, num);
			}
			if ((Object)(object)cam != (Object)null)
			{
				_priceAnchor.worldCamera = cam;
			}
			return _priceAnchor;
		}

		public static Canvas GetCaughtFishPanel(Camera cam)
		{
			//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_0033: Expected O, but got Unknown
			//IL_0033: 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_005c: 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_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: 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)
			if ((Object)(object)_caughtFishPanel == (Object)null)
			{
				GameObject val = new GameObject("HowToFishVR CaughtFishPanel", new Type[1] { typeof(RectTransform) });
				Object.DontDestroyOnLoad((Object)val);
				val.layer = 5;
				_caughtFishPanel = val.AddComponent<Canvas>();
				_caughtFishPanel.renderMode = (RenderMode)2;
				_caughtFishPanel.sortingOrder = 60;
				RectTransform val2 = (RectTransform)val.transform;
				val2.sizeDelta = new Vector2(1920f, 1080f);
				((Transform)val2).localScale = Vector3.one * (2.2f * VRConfig.HudScale.Value / 1920f);
				val.AddComponent<GraphicRaycaster>();
			}
			if ((Object)(object)cam != (Object)null)
			{
				_caughtFishPanel.worldCamera = cam;
			}
			return _caughtFishPanel;
		}

		public static void Create()
		{
			//IL_0013: 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_001e: Expected O, but got Unknown
			if (!((Object)(object)Instance != (Object)null))
			{
				GameObject val = new GameObject("HowToFishVR UI");
				Object.DontDestroyOnLoad((Object)val);
				Instance = val.AddComponent<VRUIManager>();
			}
		}

		private static bool IsDeathCanvas(Canvas c)
		{
			if ((Object)(object)c == (Object)null)
			{
				return false;
			}
			if (((Object)c).name.IndexOf("Death", StringComparison.OrdinalIgnoreCase) >= 0)
			{
				return true;
			}
			try
			{
				return (Object)(object)((Component)c).GetComponentInChildren<DeathUI>(true) != (Object)null;
			}
			catch
			{
				return false;
			}
		}

		public bool AnyMenuActive()
		{
			for (int i = 0; i < _menus.Count; i++)
			{
				if ((Object)(object)_menus[i] != (Object)null && ((Behaviour)_menus[i]).isActiveAndEnabled)
				{
					return true;
				}
			}
			return false;
		}

		internal static void ReassignLaserEventCamera(Camera eventCamera)
		{
			if ((Object)(object)eventCamera == (Object)null)
			{
				return;
			}
			LaserManagedCanvases.RemoveWhere((Canvas c) => (Object)(object)c == (Object)null);
			foreach (Canvas laserManagedCanvase in LaserManagedCanvases)
			{
				if ((Object)(object)laserManagedCanvase != (Object)null)
				{
					laserManagedCanvase.worldCamera = eventCamera;
				}
			}
		}

		internal static bool IsLaserManaged(GameObject target)
		{
			if ((Object)(object)target == (Object)null)
			{
				return false;
			}
			try
			{
				Canvas[] componentsInParent = target.GetComponentsInParent<Canvas>(true);
				foreach (Canvas val in componentsInParent)
				{
					if ((Object)(object)val != (Object)null && LaserManagedCanvases.Contains(val))
					{
						return true;
					}
				}
			}
			catch
			{
			}
			return false;
		}

		private static Camera Cam()
		{
			Camera val = null;
			try
			{
				val = GameInfo.CurCamera;
			}
			catch
			{
			}
			if ((Object)(object)val != (Object)null)
			{
				return val;
			}
			if ((Object)(object)Camera.main != (Object)null)
			{
				return Camera.main;
			}
			try
			{
				if ((Object)(object)MainMenuManager.MenuCam != (Object)null)
				{
					return MainMenuManager.MenuCam;
				}
			}
			catch
			{
			}
			Camera[] allCameras = Camera.allCameras;
			foreach (Camera val2 in allCameras)
			{
				if ((Object)(object)val2 != (Object)null && ((Behaviour)val2).isActiveAndEnabled && (Object)(object)val2.targetTexture == (Object)null)
				{
					return val2;
				}
			}
			return null;
		}

		private void LateUpdate()
		{
			if (!Plugin.VREnabled)
			{
				return;
			}
			Camera val = Cam();
			if (!((Object)(object)val == (Object)null))
			{
				_rescan -= Time.unscaledDeltaTime;
				if (_rescan <= 0f)
				{
					_rescan = ((Time.unscaledTime < _transitionScanUntil) ? 0.1f : 0.75f);
					Scan(val);
				}
			}
		}

		public void RepositionNow()
		{
			if (!Plugin.VREnabled)
			{
				return;
			}
			VRRig instance = VRRig.Instance;
			if ((Object)(object)instance == (Object)null || (Object)(object)instance.Head == (Object)null)
			{
				return;
			}
			Transform head = instance.Head;
			try
			{
				Player localPlayer = Player.LocalPlayer;
				if ((Object)(object)localPlayer != (Object)null && (Object)(object)localPlayer.Camera != (Object)null && (Object)(object)localPlayer.Camera.Cam != (Object)null)
				{
					head = ((Component)localPlayer.Camera.Cam).transform;
				}
			}
			catch
			{
			}
			Reposition(head);
			ScreenUIPatches.RePinCustomizationButtons();
			ScreenUIPatches.RePinWorldDots();
		}

		private void Scan(Camera cam)
		{
			//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_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Invalid comparison between Unknown and I4
			//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_012c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0132: Invalid comparison between Unknown and I4
			//IL_01d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01da: Invalid comparison between Unknown and I4
			//IL_01a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ae: Invalid comparison between Unknown and I4
			//IL_0454: Unknown result type (might be due to invalid IL or missing references)
			//IL_0459: Unknown result type (might be due to invalid IL or missing references)
			//IL_047f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0485: Invalid comparison between Unknown and I4
			try
			{
				Canvas[] array = Object.FindObjectsOfType<Canvas>(true);
				Scene scene;
				foreach (Canvas val in array)
				{
					if (!((Object)(object)val == (Object)null))
					{
						scene = ((Component)val).gameObject.scene;
						if (((Scene)(ref scene)).IsValid() && !((Object)val).name.StartsWith("HowToFishVR", StringComparison.Ordinal) && (int)val.renderMode == 2)
						{
							SetLayerRecursive(((Component)val).transform, 5);
						}
					}
				}
				array = Object.FindObjectsOfType<Canvas>(true);
				foreach (Canvas val2 in array)
				{
					if ((Object)(object)val2 == (Object)null || !val2.isRootCanvas)
					{
						continue;
					}
					scene = ((Component)val2).gameObject.scene;
					if (!((Scene)(ref scene)).IsValid() || ((Object)val2).name.StartsWith("HowToFishVR", StringComparison.Ordinal))
					{
						continue;
					}
					bool flag = Whitelist.Contains(((Object)val2).name) || _menus.Contains(val2) || _hudPanels.Contains(val2) || _overlays.Contains(val2);
					if (WorldAnchored.Contains(((Object)val2).name) && !flag)
					{
						ConvertWorldAnchored(val2, val2.renderOrder, cam);
						continue;
					}
					if ((int)val2.renderMode == 2)
					{
						if (flag)
						{
						}
						continue;
					}
					if (!flag)
					{
						if ((!IsFullscreen(val2) || HasButtons(val2)) && !LooksLikeBackdrop(((Object)val2).name))
						{
							ConvertHUD(val2, val2.renderOrder, cam);
						}
						continue;
					}
					int renderOrder = val2.renderOrder;
					for (int j = 0; j < _overlays.Count; j++)
					{
						Canvas val3 = _overlays[j];
						if (!((Object)(object)val3 == (Object)null) && (int)val3.renderMode == 2)
						{
							SetLayerRecursive(((Component)val3).transform, 5);
						}
					}
					if ((int)val2.renderMode == 2)
					{
						if ((((Component)val2).gameObject.layer == 5 || ((Object)(object)val2.worldCamera != (Object)null && ((Object)val2.worldCamera).name == "UICam")) && !_hudPanels.Contains(val2))
						{
							val2.worldCamera = cam;
							ApplySorting(val2, renderOrder);
							SetLayerRecursive(((Component)val2).transform, 5);
							ScaleCanvas(val2);
							_hudPanels.Add(val2);
						}
					}
					else if (!_menus.Contains(val2) && !_hudPanels.Contains(val2) && !_overlays.Contains(val2))
					{
						if (IsDeathCanvas(val2))
						{
							ConvertOverlay(val2, renderOrder, cam, forceDeath: true);
						}
						else if (Overlays.Contains(((Object)val2).name))
						{
							ConvertOverlay(val2, renderOrder, cam);
						}
						else if (HeadFollowMenus.Contains(((Object)val2).name))
						{
							ConvertHUD(val2, renderOrder, cam);
						}
						else if (HasButtons(val2))
						{
							ConvertMenu(val2, renderOrder, cam);
						}
						else
						{
							ConvertHUD(val2, renderOrder, cam);
						}
					}
				}
				for (int k = 0; k < _menus.Count; k++)
				{
					if ((Object)(object)_menus[k] != (Object)null)
					{
						NeutralizeFullscreenPanels(_menus[k]);
						NormalizeBlurMaterials(_menus[k]);
					}
				}
				for (int l = 0; l < _hudPanels.Count; l++)
				{
					if ((Object)(object)_hudPanels[l] != (Object)null)
					{
						NeutralizeFullscreenPanels(_hudPanels[l]);
						NormalizeBlurMaterials(_hudPanels[l]);
					}
				}
				FishingUI[] array2 = Object.FindObjectsOfType<FishingUI>(true);
				foreach (FishingUI val4 in array2)
				{
					if ((Object)(object)val4 != (Object)null)
					{
						ConvertHostAsHud((Component)(object)val4, cam);
					}
				}
				ItemUI[] array3 = Object.FindObjectsOfType<ItemUI>(true);
				foreach (ItemUI val5 in array3)
				{
					if ((Object)(object)val5 != (Object)null)
					{
						ConvertHostAsHud((Component)(object)val5, cam);
					}
				}
				array = Object.FindObjectsOfType<Canvas>(true);
				foreach (Canvas val6 in array)
				{
					if ((Object)(object)val6 == (Object)null || val6.isRootCanvas)
					{
						continue;
					}
					scene = ((Component)val6).gameObject.scene;
					if (((Scene)(ref scene)).IsValid() && !((Object)val6).name.StartsWith("HowToFishVR", StringComparison.Ordinal) && (int)val6.renderMode != 2)
					{
						Canvas rootCanvas = val6.rootCanvas;
						if (!((Object)(object)rootCanvas == (Object)null) && !((Object)rootCanvas).name.StartsWith("HowToFishVR", StringComparison.Ordinal) && (_menus.Contains(rootCanvas) || _hudPanels.Contains(rootCanvas) || _overlays.Contains(rootCanvas)))
						{
							val6.renderMode = (RenderMode)2;
							val6.worldCamera = cam;
							SetLayerRecursive(((Component)val6).transform, 5);
							NormalizeBlurMaterials(val6);
							AddLaserRaycaster(val6);
						}
					}
				}
			}
			catch
			{
			}
		}

		private void ConvertMenu(Canvas c, int order, Camera cam)
		{
			PrepareLayout(c);
			c.renderMode = (RenderMode)2;
			c.worldCamera = cam;
			ApplySorting(c, order);
			SetLayerRecursive(((Component)c).transform, 5);
			NeutralizeFullscreenPanels(c);
			NormalizeBlurMaterials(c);
			AddLaserRaycaster(c);
			ScaleCanvas(c);
			_menus.Add(c);
			PlaceMenu(c, ((Component)cam).transform);
			if (((Behaviour)c).isActiveAndEnabled)
			{
				_activeMenus.Add(((Object)c).GetInstanceID());
			}
		}

		private void ConvertHUD(Canvas c, int order, Camera cam)
		{
			PrepareLayout(c);
			c.renderMode = (RenderMode)2;
			c.worldCamera = cam;
			ApplySorting(c, order);
			SetLayerRecursive(((Component)c).transform, 5);
			NeutralizeFullscreenPanels(c);
			NormalizeBlurMaterials(c);
			ScaleCanvas(c);
			AddLaserRaycaster(c);
			_hudPanels.Add(c);
		}

		private void ConvertOverlay(Canvas c, int order, Camera cam, bool forceDeath = false)
		{
			//IL_005e: 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_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: 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)
			try
			{
				PrepareLayout(c);
				c.renderMode = (RenderMode)2;
				c.worldCamera = cam;
				ApplySorting(c, order + 1000);
				SetLayerRecursive(((Component)c).transform, 5);
				if (((Object)c).name.IndexOf("Underwater", StringComparison.OrdinalIgnoreCase) >= 0)
				{
					MakeUnderwaterStereoSafe(c);
				}
				NormalizeBlurMaterials(c);
				RectTransform component = ((Component)c).GetComponent<RectTransform>();
				if ((Object)(object)component != (Object)null)
				{
					Rect rect = component.rect;
					float num;
					if (!(((Rect)(ref rect)).width > 1f))
					{
						num = Mathf.Max(1f, component.sizeDelta.x);
					}
					else
					{
						rect = component.rect;
						num = ((Rect)(ref rect)).width;
					}
					float num2 = num;
					float num3 = 2.6f * VRConfig.HudScale.Value / num2;
					((Transform)component).localScale = new Vector3(num3, num3, num3);
				}
				int num4;
				if (!forceDeath)
				{
					num4 = (IsDeathCanvas(c) ? 1 : 0);
					if (num4 == 0)
					{
						goto IL_00f1;
					}
				}
				else
				{
					num4 = 1;
				}
				if ((Object)(object)cam != (Object)null)
				{
					((Component)c).transform.SetParent(((Component)cam).transform, false);
				}
				_deathOverlays.Add(c);
				goto IL_00f1;
				IL_00f1:
				_overlays.Add(c);
				if (num4 != 0)
				{
					try
					{
						SoftenDeathBackdrop(c);
						return;
					}
					catch
					{
						return;
					}
				}
			}
			catch
			{
			}
		}

		public void SyncDeathOverlay(DeathUI deathUI, bool show)
		{
			//IL_00e4: 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_00fe: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if ((Object)(object)deathUI == (Object)null || (Object)(object)deathUI._deathCanvas == (Object)null)
				{
					return;
				}
				Camera val = Cam();
				Canvas val2 = EnsureDedicatedDeathPanel(deathUI, val);
				if ((Object)(object)val2 == (Object)null)
				{
					return;
				}
				SetLayerRecursive(((Component)val2).transform, 5);
				((Behaviour)val2).enabled = true;
				((Component)val2).gameObject.SetActive(true);
				((Component)deathUI._deathCanvas).gameObject.SetActive(true);
				if (!show)
				{
					return;
				}
				Transform val3 = (((Object)(object)val != (Object)null) ? ((Component)val).transform : null);
				try
				{
					Player localPlayer = Player.LocalPlayer;
					if ((Object)(object)localPlayer != (Object)null && (Object)(object)localPlayer.Camera != (Object)null && (Object)(object)localPlayer.Camera.Cam != (Object)null)
					{
						val3 = ((Component)localPlayer.Camera.Cam).transform;
					}
				}
				catch
				{
				}
				if ((Object)(object)val3 != (Object)null)
				{
					((Component)val2).transform.SetParent(val3, false);
					((Component)val2).transform.localPosition = Vector3.forward * 1.5f;
					((Component)val2).transform.localRotation = Quaternion.identity;
					ScaleDeathPanel(val2);
				}
				SoftenDeathBackdrop(val2);
			}
			catch
			{
			}
		}

		private Canvas EnsureDedicatedDeathPanel(DeathUI deathUI, Camera cam)
		{
			//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_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_deathPanel != (Object)null && (Object)(object)_deathPanelOwner == (Object)(object)deathUI)
			{
				_deathPanel.worldCamera = cam;
				return _deathPanel;
			}
			Canvas componentInParent = ((Component)deathUI._deathCanvas).GetComponentInParent<Canvas>(true);
			GameObject val = new GameObject("HowToFishVR DeathPanel", new Type[1] { typeof(RectTransform) })
			{
				layer = 5
			};
			Canvas val2 = val.AddComponent<Canvas>();
			val2.renderMode = (RenderMode)2;
			val2.worldCamera = cam;
			val2.overrideSorting = true;
			val2.sortingOrder = (((Object)(object)componentInParent != (Object)null) ? componentInParent.sortingOrder : 12) + 1000;
			((RectTransform)val.transform).sizeDelta = new Vector2(1920f, 1080f);
			((Component)deathUI._deathCanvas).transform.SetParent(((Component)val2).transform, false);
			((Component)deathUI._deathCanvas).transform.localScale = Vector3.one;
			SetLayerRecursive(((Component)val2).transform, 5);
			if ((Object)(object)componentInParent != (Object)null && (Object)(object)componentInParent != (Object)(object)val2)
			{
				_overlays.Remove(componentInParent);
				_deathOverlays.Remove(componentInParent);
				((Behaviour)componentInParent).enabled = false;
			}
			_deathPanel = val2;
			_deathPanelOwner = deathUI;
			_overlays.Add(val2);
			_deathOverlays.Add(val2);
			ScaleDeathPanel(val2);
			return val2;
		}

		private static void ScaleDeathPanel(Canvas panel)
		{
			//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_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: 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_0070: Unknown result type (might be due to invalid IL or missing references)
			RectTransform val = (((Object)(object)panel != (Object)null) ? ((Component)panel).GetComponent<RectTransform>() : null);
			if (!((Object)(object)val == (Object)null))
			{
				Rect rect = val.rect;
				float num;
				if (!(((Rect)(ref rect)).width > 1f))
				{
					num = Mathf.Max(1f, val.sizeDelta.x);
				}
				else
				{
					rect = val.rect;
					num = ((Rect)(ref rect)).width;
				}
				float num2 = num;
				((Transform)val).localScale = Vector3.one * (3f * VRConfig.HudScale.Value / num2);
			}
		}

		private static void MakeUnderwaterStereoSafe(Canvas c)
		{
			//IL_00d7: 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_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: 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)
			try
			{
				Material defaultCanvasMaterial = Canvas.GetDefaultCanvasMaterial();
				if ((Object)(object)defaultCanvasMaterial == (Object)null)
				{
					return;
				}
				Image[] componentsInChildren = ((Component)c).GetComponentsInChildren<Image>(true);
				foreach (Image val in componentsInChildren)
				{
					if (!((Object)(object)val == (Object)null) && !((Object)(object)((Graphic)val).material == (Object)null))
					{
						Material material = ((Graphic)val).material;
						string obj = ((Object)material).name ?? "";
						string text = (((Object)(object)material.shader != (Object)null) ? (((Object)material.shader).name ?? "") : "");
						if (obj.IndexOf("Underwater", StringComparison.OrdinalIgnoreCase) >= 0 || text.IndexOf("Underwater", StringComparison.OrdinalIgnoreCase) >= 0)
						{
							Color val2 = (Color)(material.HasProperty("_UnderwaterColor") ? material.GetColor("_UnderwaterColor") : new Color(0f, 0.466f, 0.67f, 1f));
							float num = Mathf.Clamp01(((Graphic)val).color.a);
							((Graphic)val).material = defaultCanvasMaterial;
							((Graphic)val).color = new Color(val2.r, val2.g, val2.b, 0.2f * num);
						}
					}
				}
			}
			catch
			{
			}
		}

		private static void SoftenDeathBackdrop(Canvas c)
		{
			//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_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)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: 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_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_014e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0153: Unknown result type (might be due to invalid IL or missing references)
			//IL_0158: Unknown result type (might be due to invalid IL or missing references)
			//IL_015c: Unknown result type (might be due to invalid IL or missing references)
			//IL_016c: Unknown result type (might be due to invalid IL or missing references)
			//IL_017c: Unknown result type (might be due to invalid IL or missing references)
			//IL_018c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e9: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				RectTransform component = ((Component)c).GetComponent<RectTransform>();
				if ((Object)(object)component == (Object)null)
				{
					return;
				}
				Rect rect = component.rect;
				float width = ((Rect)(ref rect)).width;
				rect = component.rect;
				float height = ((Rect)(ref rect)).height;
				if (width < 1f || height < 1f)
				{
					return;
				}
				Vector3[] array = (Vector3[])(object)new Vector3[4];
				Image[] componentsInChildren = ((Component)c).GetComponentsInChildren<Image>(true);
				foreach (Image val in componentsInChildren)
				{
					if ((Object)(object)val == (Object)null || !((Component)val).gameObject.activeSelf)
					{
						continue;
					}
					Color color = ((Graphic)val).color;
					float num = (color.r + color.g + color.b) / 3f;
					if (num > 0.35f)
					{
						if (!((Object)(object)val.sprite != (Object)null) || !((Object)(object)val.sprite.texture != (Object)null))
						{
							continue;
						}
						float num2 = SampleSpriteCenter(val.sprite);
						if (num2 > 0.35f)
						{
							continue;
						}
						num = Mathf.Min(num, num2);
					}
					RectTransform rectTransform = ((Graphic)val).rectTransform;
					if (!((Object)(object)rectTransform == (Object)null))
					{
						rectTransform.GetWorldCorners(array);
						float num3 = float.MaxValue;
						float num4 = float.MaxValue;
						float num5 = float.MinValue;
						float num6 = float.MinValue;
						for (int j = 0; j < 4; j++)
						{
							Vector3 val2 = ((Component)c).transform.InverseTransformPoint(array[j]);
							num3 = Mathf.Min(num3, val2.x);
							num4 = Mathf.Min(num4, val2.y);
							num5 = Mathf.Max(num5, val2.x);
							num6 = Mathf.Max(num6, val2.y);
						}
						if (num5 - num3 >= width * 0.85f && num6 - num4 >= height * 0.85f)
						{
							((Graphic)val).color = new Color(color.r, color.g, color.b, Mathf.Min(color.a, 0.55f));
						}
					}
				}
			}
			catch
			{
			}
		}

		private static void AddLaserRaycaster(Canvas c)
		{
			GraphicRaycaster val = ((Component)c).GetComponent<GraphicRaycaster>();
			if ((Object)(object)val == (Object)null)
			{
				val = ((Component)c).gameObject.AddComponent<GraphicRaycaster>();
			}
			((Behaviour)val).enabled = true;
			val.ignoreReversedGraphics = false;
			val.blockingObjects = (BlockingObjects)0;
			TrackedDeviceGraphicRaycaster component = ((Component)c).GetComponent<TrackedDeviceGraphicRaycaster>();
			if ((Object)(object)component != (Object)null)
			{
				((Behaviour)component).enabled = false;
			}
			LaserManagedCanvases.Add(c);
		}

		private static void PrepareLayout(Canvas c)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Invalid comparison between Unknown and I4
			//IL_006d: 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_0044: 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)
			RectTransform component = ((Component)c).GetComponent<RectTransform>();
			Vector2 referenceResolution = default(Vector2);
			((Vector2)(ref referenceResolution))..ctor(1920f, 1080f);
			CanvasScaler component2 = ((Component)c).GetComponent<CanvasScaler>();
			if ((Object)(object)component2 != (Object)null)
			{
				if ((int)component2.uiScaleMode == 1 && component2.referenceResolution.x > 1f && component2.referenceResolution.y > 1f)
				{
					referenceResolution = component2.referenceResolution;
				}
				((Behaviour)component2).enabled = false;
			}
			if ((Object)(object)component != (Object)null)
			{
				component.sizeDelta = referenceResolution;
			}
		}

		private static bool HasButtons(Canvas c)
		{
			try
			{
				Selectable[] componentsInChildren = ((Component)c).GetComponentsInChildren<Selectable>(true);
				return componentsInChildren != null && componentsInChildren.Length != 0;
			}
			catch
			{
				return false;
			}
		}

		private static bool IsFullscreen(Canvas c)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: 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)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				RectTransform component = ((Component)c).GetComponent<RectTransform>();
				if ((Object)(object)component == (Object)null)
				{
					return false;
				}
				Rect rect = component.rect;
				float num;
				if (!(((Rect)(ref rect)).width > 1f))
				{
					num = component.sizeDelta.x;
				}
				else
				{
					rect = component.rect;
					num = ((Rect)(ref rect)).width;
				}
				float num2 = num;
				rect = component.rect;
				float num3;
				if (!(((Rect)(ref rect)).height > 1f))
				{
					num3 = component.sizeDelta.y;
				}
				else
				{
					rect = component.rect;
					num3 = ((Rect)(ref rect)).height;
				}
				float num4 = num3;
				return num2 >= 800f && num2 / Mathf.Max(1f, num4) >= 1.5f;
			}
			catch
			{
				return false;
			}
		}

		private static bool LooksLikeBackdrop(string name)
		{
			string[] backdropNameHints = BackdropNameHints;
			foreach (string value in backdropNameHints)
			{
				if (name.IndexOf(value, StringComparison.OrdinalIgnoreCase) >= 0)
				{
					return true;
				}
			}
			return false;
		}

		public static void ForceHostAsHud(Transform t)
		{
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Invalid comparison between Unknown and I4
			try
			{
				if ((Object)(object)t == (Object)null || (Object)(object)Instance == (Object)null)
				{
					return;
				}
				Canvas componentInParent = ((Component)t).GetComponentInParent<Canvas>(true);
				if ((Object)(object)componentInParent == (Object)null)
				{
					return;
				}
				Canvas rootCanvas = componentInParent.rootCanvas;
				if (!((Object)(object)rootCanvas == (Object)null) && !((Object)rootCanvas).name.StartsWith("HowToFishVR", StringComparison.Ordinal) && !Instance._menus.Contains(rootCanvas) && !Instance._hudPanels.Contains(rootCanvas) && !Instance._overlays.Contains(rootCanvas) && (int)rootCanvas.renderMode != 2)
				{
					Camera val = Cam();
					if (!((Object)(object)val == (Object)null))
					{
						Instance.ConvertHUD(rootCanvas, rootCanvas.renderOrder, val);
					}
				}
			}
			catch
			{
			}
		}

		private static void NeutralizeFullscreenPanels(Canvas c)
		{
			//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_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)
			//IL_0151: Unknown result type (might be due to invalid IL or missing references)
			//IL_0156: Unknown result type (might be due to invalid IL or missing references)
			//IL_0158: 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_0170: Unknown result type (might be due to invalid IL or missing references)
			//IL_0178: Unknown result type (might be due to invalid IL or missing references)
			//IL_0227: Unknown result type (might be due to invalid IL or missing references)
			//IL_022c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0231: Unknown result type (might be due to invalid IL or missing references)
			//IL_0235: Unknown result type (might be due to invalid IL or missing references)
			//IL_0245: Unknown result type (might be due to invalid IL or missing references)
			//IL_0255: Unknown result type (might be due to invalid IL or missing references)
			//IL_0265: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				RectTransform component = ((Component)c).GetComponent<RectTransform>();
				if ((Object)(object)component == (Object)null)
				{
					return;
				}
				Rect rect = component.rect;
				float width = ((Rect)(ref rect)).width;
				rect = component.rect;
				float height = ((Rect)(ref rect)).height;
				if (width < 1f || height < 1f)
				{
					return;
				}
				Vector3[] array = (Vector3[])(object)new Vector3[4];
				Image[] componentsInChildren = ((Component)c).GetComponentsInChildren<Image>(true);
				foreach (Image val in componentsInChildren)
				{
					if ((Object)(object)val == (Object)null || !((Component)val).gameObject.activeSelf || ((Object)(object)((Graphic)val).material != (Object)null && (Object)(object)((Graphic)val).material.shader != (Object)null && ((((Object)((Graphic)val).material).name ?? "").IndexOf("Blur", StringComparison.OrdinalIgnoreCase) >= 0 || (((Object)((Graphic)val).material.shader).name ?? "").IndexOf("Blur", StringComparison.OrdinalIgnoreCase) >= 0)))
					{
						continue;
					}
					Transform val2 = ((Component)val).transform;
					bool flag = false;
					while ((Object)(object)val2 != (Object)null)
					{
						if (((Object)val2).name.StartsWith("HowToFishVR", StringComparison.Ordinal))
						{
							flag = true;
							break;
						}
						val2 = val2.parent;
					}
					if (flag || (Object)(object)((Component)val).GetComponentInParent<Button>(true) != (Object)null)
					{
						continue;
					}
					Color color = ((Graphic)val).color;
					if (color.a < 0.15f)
					{
						continue;
					}
					float num = (color.r + color.g + color.b) / 3f;
					if (!(num <= 0.35f))
					{
						if (!((Object)(object)val.sprite != (Object)null) || !((Object)(object)val.sprite.texture != (Object)null))
						{
							continue;
						}
						float num2 = SampleSpriteCenter(val.sprite);
						if (num2 > 0.35f)
						{
							continue;
						}
						num = Mathf.Min(num, num2);
					}
					RectTransform rectTransform = ((Graphic)val).rectTransform;
					if (!((Object)(object)rectTransform == (Object)null))
					{
						rectTransform.GetWorldCorners(array);
						float num3 = float.MaxValue;
						float num4 = float.MaxValue;
						float num5 = float.MinValue;
						float num6 = float.MinValue;
						for (int j = 0; j < 4; j++)
						{
							Vector3 val3 = ((Component)c).transform.InverseTransformPoint(array[j]);
							num3 = Mathf.Min(num3, val3.x);
							num4 = Mathf.Min(num4, val3.y);
							num5 = Mathf.Max(num5, val3.x);
							num6 = Mathf.Max(num6, val3.y);
						}
						if (num5 - num3 >= width * 0.85f && num6 - num4 >= height * 0.85f)
						{
							((Component)val).gameObject.SetActive(false);
						}
					}
				}
			}
			catch
			{
			}
		}

		private static void NormalizeBlurMaterials(Canvas c)
		{
		}

		private static float SampleSpriteCenter(Sprite s)
		{
			//IL_0008: 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_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: 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_009f: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				Texture2D texture = s.texture;
				Rect textureRect = s.textureRect;
				if ((Object)(object)texture == (Object)null || ((Rect)(ref textureRect)).width < 2f || ((Rect)(ref textureRect)).height < 2f)
				{
					return 1f;
				}
				int num = Mathf.Clamp((int)(((Rect)(ref textureRect)).x + ((Rect)(ref textureRect)).width * 0.5f), 0, ((Texture)texture).width - 1);
				int num2 = Mathf.Clamp((int)(((Rect)(ref textureRect)).y + ((Rect)(ref textureRect)).height * 0.5f), 0, ((Texture)texture).height - 1);
				Color pixel = texture.GetPixel(num, num2);
				return (pixel.r + pixel.g + pixel.b) / 3f;
			}
			catch
			{
				return 1f;
			}
		}

		private void ConvertWorldAnchored(Canvas c, int order, Camera cam)
		{
			//IL_0032: 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_005e: 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_004c: 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)
			c.renderMode = (RenderMode)2;
			c.worldCamera = cam;
			ApplySorting(c, order);
			SetLayerRecursive(((Component)c).transform, 5);
			RectTransform component = ((Component)c).GetComponent<RectTransform>();
			if ((Object)(object)component != (Object)null)
			{
				Rect rect = component.rect;
				float num;
				if (!(((Rect)(ref rect)).width > 1f))
				{
					num = Mathf.Max(1f, component.sizeDelta.x);
				}
				else
				{
					rect = component.rect;
					num = ((Rect)(ref rect)).width;
				}
				float num2 = num;
				float num3 = 2.2f * VRConfig.HudScale.Value / num2;
				((Transform)component).localScale = new Vector3(num3, num3, num3);
			}
		}

		private static void ConvertHostAsHud(Component src, Camera cam)
		{
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Invalid comparison between Unknown and I4
			if ((Object)(object)src == (Object)null)
			{
				return;
			}
			try
			{
				Canvas componentInParent = src.GetComponentInParent<Canvas>(true);
				if (!((Object)(object)componentInParent == (Object)null))
				{
					componentInParent = componentInParent.rootCanvas;
					if (!((Object)(object)componentInParent == (Object)null) && !((Object)componentInParent).name.StartsWith("HowToFishVR", StringComparison.Ordinal) && !Whitelist.Contains(((Object)componentInParent).name) && !((Object)componentInParent).name.StartsWith("ItemDots", StringComparison.Ordinal) && (!((Object)(object)Instance != (Object)null) || (!Instance._menus.Contains(componentInParent) && !Instance._hudPanels.Contains(componentInParent) && !Instance._overlays.Contains(componentInParent))) && (int)componentInParent.renderMode != 2)
					{
						Instance.ConvertHUD(componentInParent, componentInParent.renderOrder, cam);
					}
				}
			}
			catch
			{
			}
		}

		private static void ApplySorting(Canvas canvas, int order)
		{
			if (!((Object)(object)canvas == (Object)null))
			{
				canvas.overrideSorting = true;
				canvas.sortingOrder = order;
			}
		}

		private void Reposition(Transform head)
		{
			//IL_0001: 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_040b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0410: 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_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: 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_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: 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_0263: Unknown result type (might be due to invalid IL or missing references)
			//IL_0274: Unknown result type (might be due to invalid IL or missing references)
			//IL_043a: Unknown result type (might be due to invalid IL or missing references)
			//IL_043f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0427: 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_0053: Invalid comparison between Unknown and I4
			//IL_02b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b9: Invalid comparison between Unknown and I4
			//IL_046c: Unknown result type (might be due to invalid IL or missing references)
			//IL_012c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0132: Invalid comparison between Unknown and I4
			//IL_01f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0209: Unknown result type (might be due to invalid IL or missing references)
			//IL_048d: 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_014b: Unknown result type (might be due to invalid IL or missing references)
			//IL_016b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0193: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_036b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0375: Unknown result type (might be due to invalid IL or missing references)
			//IL_0386: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ab: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				float y = head.eulerAngles.y;
				Quaternion val = Quaternion.Euler(0f, y, 0f);
				bool flag = false;
				try
				{
					flag = MainMenuManager.IsInMenu;
				}
				catch
				{
				}
				for (int i = 0; i < _menus.Count; i++)
				{
					Canvas val2 = _menus[i];
					if ((Object)(object)val2 == (Object)null || (int)val2.renderMode != 2)
					{
						continue;
					}
					int instanceID = ((Object)val2).GetInstanceID();
					bool flag2 = ((Behaviour)val2).isActiveAndEnabled;
					if (((Object)val2).name == "PauseCanvas")
					{
						try
						{
							flag2 = PauseManager.IsPaused || VRSettingsPanel.IsOpen;
						}
						catch
						{
						}
					}
					if (!flag2)
					{
						_activeMenus.Remove(instanceID);
						continue;
					}
					bool flag3 = _activeMenus.Add(instanceID);
					if (flag || flag3)
					{
						PlaceMenu(val2, head);
					}
				}
				Vector3 position = head.position + val * Vector3.forward * 2f;
				for (int j = 0; j < _hudPanels.Count; j++)
				{
					Canvas val3 = _hudPanels[j];
					if ((Object)(object)val3 == (Object)null || !((Behaviour)val3).isActiveAndEnabled || (int)val3.renderMode != 2)
					{
						continue;
					}
					((Component)val3).transform.position = position;
					((Component)val3).transform.rotation = val;
					RectTransform component = ((Component)val3).GetComponent<RectTransform>();
					if ((Object)(object)component != (Object)null)
					{
						float num = Mathf.Max(1f, component.sizeDelta.x);
						float num2 = 2.2f * VRConfig.HudScale.Value / num;
						if (Mathf.Abs(((Transform)component).localScale.x - num2) > 1E-05f)
						{
							((Transform)component).localScale = new Vector3(num2, num2, num2);
						}
					}
				}
				if ((Object)(object)_caughtFishPanel != (Object)null && ((Behaviour)_caughtFishPanel).isActiveAndEnabled)
				{
					((Component)_caughtFishPanel).transform.position = position;
					((Component)_caughtFishPanel).transform.rotation = val;
				}
				bool flag4 = false;
				try
				{
					Player localPlayer = Player.LocalPlayer;
					flag4 = (Object)(object)localPlayer != (Object)null && (Object)(object)localPlayer.Dying != (Object)null && localPlayer.Dying.IsDead;
				}
				catch
				{
				}
				bool flag5 = false;
				try
				{
					Camera val4 = Cam();
					if ((Object)(object)val4 != (Object)null)
					{
						flag5 = ((Component)val4).transform.position.y < WaterManager.GetWaterHeight(((Component)val4).transform.position) + 0.1f;
					}
				}
				catch
				{
				}
				for (int k = 0; k < _overlays.Count; k++)
				{
					Canvas val5 = _overlays[k];
					if ((Object)(object)val5 == (Object)null || (int)val5.renderMode != 2)
					{
						continue;
					}
					bool flag6 = _deathOverlays.Contains(val5) || IsDeathCanvas(val5);
					if (((Object)val5).name.IndexOf("Underwater", StringComparison.OrdinalIgnoreCase) >= 0 && flag4)
					{
						if (flag5)
						{
							if (!((Component)val5).gameObject.activeSelf)
							{
								((Component)val5).gameObject.SetActive(true);
							}
						}
						else if (((Component)val5).gameObject.activeSelf)
						{
							((Component)val5).gameObject.SetActive(false);
						}
					}
					if (!((Behaviour)val5).isActiveAndEnabled)
					{
						continue;
					}
					if (flag6)
					{
						if ((Object)(object)((Component)val5).transform.parent != (Object)(object)head)
						{
							((Component)val5).transform.SetParent(head, false);
						}
						((Component)val5).transform.localPosition = Vector3.forward * 1.5f;
						((Component)val5).transform.localRotation = Quaternion.identity;
						try
						{
							CanvasGroup componentInChildren = ((Component)val5).GetComponentInChildren<CanvasGroup>(true);
							if ((Object)(object)componentInChildren != (Object)null)
							{
								((Component)componentInChildren).transform.localScale = Vector3.one;
							}
						}
						catch
						{
						}
					}
					else
					{
						((Component)val5).transform.position = head.position + head.forward * 0.4f;
						((Component)val5).transform.rotation = head.rotation;
					}
					RectTransform component2 = ((Component)val5).GetComponent<RectTransform>();
					if ((Object)(object)component2 != (Object)null)
					{
						Rect rect = component2.rect;
						float num3;
						if (!(((Rect)(ref rect)).width > 1f))
						{
							num3 = Mathf.Max(1f, component2.sizeDelta.x);
						}
						else
						{
							rect = component2.rect;
							num3 = ((Rect)(ref rect)).width;
						}
						float num4 = num3;
						float num5 = (flag6 ? 3f : 2.6f) * VRConfig.HudScale.Value / num4;
						if (Mathf.Abs(((Transform)component2).localScale.x - num5) > 1E-05f)
						{
							((Transform)component2).localScale = new Vector3(num5, num5, num5);
						}
					}
				}
			}
			catch
			{
			}
		}

		private static void PlaceMenu(Canvas canvas, Transform head)
		{
			//IL_0019: 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_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)
			//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)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)canvas == (Object)null) && !((Object)(object)head == (Object)null))
			{
				Quaternion val = Quaternion.Euler(0f, head.eulerAngles.y, 0f);
				((Component)canvas).transform.position = head.position + val * Vector3.forward * 2f;
				((Component)canvas).transform.rotation = val;
			}
		}

		private static void ScaleCanvas(Canvas c)
		{
			//IL_0023: 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)
			RectTransform val = (((Object)(object)c != (Object)null) ? ((Component)c).GetComponent<RectTransform>() : null);
			if (!((Object)(object)val == (Object)null))
			{
				float num = Mathf.Max(1f, val.sizeDelta.x);
				float num2 = 2.2f * VRConfig.HudScale.Value / num;
				((Transform)val).localScale = new Vector3(num2, num2, num2);
			}
		}

		private static void SetLayerRecursive(Transform root, int layer)
		{
			if (!((Object)(object)root == (Object)null))
			{
				((Component)root).gameObject.layer = layer;
				for (int i = 0; i < root.childCount; i++)
				{
					SetLayerRecursive(root.GetChild(i), layer);
				}
			}
		}
	}
}
namespace HowToFishVR.Patches
{
	[HarmonyPatch]
	internal static class CameraOutputPatches
	{
		private static readonly HashSet<Camera> Managed = new HashSet<Camera>();

		public static void SetupForVR(Camera cam)
		{
			Apply(cam);
		}

		public static void EnsureXR(Camera cam)
		{
			if ((Object)(object)cam == (Object)null)
			{
				return;
			}
			try
			{
				cam.cullingMask |= 0x20;
				UniversalAdditionalCameraData universalAdditionalCameraData = CameraExtensions.GetUniversalAdditionalCameraData(cam);
				if ((Object)(object)universalAdditionalCameraData != (Object)null)
				{
					if (!universalAdditionalCameraData.allowXRRendering)
					{
						universalAdditionalCameraData.allowXRRendering = true;
					}
					if (universalAdditionalCameraData.renderPostProcessing)
					{
						universalAdditionalCameraData.renderPostProcessing = false;
					}
				}
			}
			catch
			{
			}
		}

		public static void EnsureAll()
		{
			Camera[] allCameras = Camera.allCameras;
			foreach (Camera val in allCameras)
			{
				if (!((Object)(object)val == (Object)null) && ((Behaviour)val).isActiveAndEnabled && !((Object)(object)val.targetTexture != (Object)null))
				{
					Apply(val);
				}
			}
		}

		private static void Apply(Camera cam)
		{
			if ((Object)(object)cam == (Object)null)
			{
				return;
			}
			Managed.Add(cam);
			if ((Object)(object)cam.targetTexture != (Object)null)
			{
				cam.targetTexture = null;
			}
			try
			{
				UniversalAdditionalCameraData universalAdditionalCameraData = CameraExtensions.GetUniversalAdditionalCameraData(cam);
				if ((Object)(object)universalAdditionalCameraData != (Object)null)
				{
					if (!universalAdditionalCameraData.allowXRRendering)
					{
						universalAdditionalCameraData.allowXRRendering = true;
					}
					if (universalAdditionalCameraData.renderPostProcessing)
					{
						universalAdditionalCameraData.renderPostProcessing = false;
					}
				}
			}
			catch
			{
			}
		}

		private static bool IsMainCamera(Camera cam)
		{
			if ((Object)(object)cam == (Object)null)
			{
				return false;
			}
			if (Managed.Contains(cam))
			{
				return true;
			}
			if ((Object)(object)cam == (Object)(object)GameInfo.CurCamera)
			{
				return true;
			}
			try
			{
				if ((Object)(object)cam == (Object)(object)MainMenuManager.MenuCam)
				{
					return true;
				}
			}
			catch
			{
			}
			return false;
		}

		[HarmonyPatch(/*Could not decode attribute arguments.*/)]
		[HarmonyPrefix]
		private static void BlockMainTargetTexture(Camera __instance, ref RenderTexture value)
		{
			if (Plugin.VREnabled && (Object)(object)value != (Object)null && IsMainCamera(__instance))
			{
				value = null;
			}
		}
	}
	[HarmonyPatch]
	internal static class DropComboPatches
	{
		private static bool OffHandGripHeld()
		{
			try
			{
				VRActions instance = VRActions.Instance;
				if (instance == null)
				{
					return false;
				}
				return instance.OffHandGrip >= VRConfig.GripThreshold.Value;
			}
			catch
			{
				return false;
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(PlayerHolding), "DropInput")]
		private static bool GateDropInput()
		{
			if (!Plugin.VREnabled)
			{
				return true;
			}
			if (PlayerToolMovementPatches.GunTwoHand)
			{
				return false;
			}
			return OffHandGripHeld();
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(PlayerInventory), "ChangeBaitInput")]
		private static bool GateChangeBait(CallbackContext context)
		{
			if (!Plugin.VREnabled)
			{
				return true;
			}
			return !OffHandGripHeld();
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(PlayerHolding), "FinalDropForce")]
		private static void AimThrowWithHand(PlayerHolding __instance, ref Vector3 __result)
		{
			//IL_015d: Unknown result type (might be due to invalid IL or missing references)
			//IL_015f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0161: Unknown result type (might be due to invalid IL or missing references)
			//IL_0163: 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_016d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0174: Unknown result type (might be due to invalid IL or missing references)
			//IL_0179: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0191: Unknown result type (might be due to invalid IL or missing references)
			//IL_0195: Unknown result type (might be due to invalid IL or missing references)
			//IL_019a: Unknown result type (might be due to invalid IL or missing references)
			//IL_019c: Unknown result type (might be due to invalid IL or missing references)
			//IL_019e: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c5: 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_01cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d9: 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_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_0086: 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_0090: 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_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: 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_00ee: 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_00d6: 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_0114: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: 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_0141: 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_0151: Unknown result type (might be due to invalid IL or missing references)
			//IL_0156: Unknown result type (might be due to invalid IL or missing references)
			if (!Plugin.VREnabled)
			{
				return;
			}
			try
			{
				Item heldItem = __instance._heldItem;
				if ((Object)(object)heldItem != (Object)null && (Object)(object)heldItem.Tool != (Object)null)
				{
					return;
				}
				VRRig instance = VRRig.Instance;
				if ((Object)(object)instance == (Object)null || (Object)(object)instance.MainHand == (Object)null)
				{
					return;
				}
				float magnitude = ((Vector3)(ref __result)).magnitude;
				if (magnitude < 0.001f)
				{
					return;
				}
				Vector3 val = instance.MainHand.rotation * Quaternion.Euler(45f, 0f, 0f) * Vector3.forward;
				Vector3 val2 = Vector3.zero;
				bool flag = false;
				InputDevice deviceAtXRNode = InputDevices.GetDeviceAtXRNode((XRNode)5);
				Vector3 val3 = default(Vector3);
				if (((InputDevice)(ref deviceAtXRNode)).isValid && ((InputDevice)(ref deviceAtXRNode)).TryGetFeatureValue(CommonUsages.deviceVelocity, ref val3))
				{
					val2 = (((Object)(object)instance.Root != (Object)null) ? instance.Root.TransformDirection(val3) : val3);
					flag = true;
				}
				Vector3 val4 = default(Vector3);
				if (((InputDevice)(ref deviceAtXRNode)).isValid && ((InputDevice)(ref deviceAtXRNode)).TryGetFeatureValue(CommonUsages.deviceAngularVelocity, ref val4))
				{
					Vector3 val5 = (((Object)(object)instance.Root != (Object)null) ? instance.Root.TransformDirection(val4) : val4);
					Vector3 val6 = Vector3.zero;
					try
					{
						if ((Object)(object)heldItem != (Object)null && (Object)(object)heldItem.Rig != (Object)null)
						{
							val6 = heldItem.Rig.worldCenterOfMass - instance.MainHand.position;
						}
					}
					catch
					{
					}
					val2 += Vector3.Cross(val5, val6);
					flag = true;
				}
				Vector3 normalized = ((Vector3)(ref val)).normalized;
				float magnitude2 = ((Vector3)(ref val2)).magnitude;
				if (flag && magnitude2 > 0.2f)
				{
					Vector3 val7 = val2 / magnitude2;
					if (Vector3.Dot(val7, normalized) > -0.15f)
					{
						float num = Mathf.InverseLerp(0.2f, 1.75f, magnitude2) * 0.8f;
						Vector3 val8 = Vector3.Slerp(normalized, val7, num);
						normalized = ((Vector3)(ref val8)).normalized;
					}
				}
				if (!(((Vector3)(ref normalized)).sqrMagnitude < 1E-06f))
				{
					__result = normalized * magnitude;
				}
			}
			catch
			{
			}
		}
	}
	[HarmonyPatch(typeof(Tool))]
	internal static class ToolHandPatches
	{
		[HarmonyPrefix]
		[HarmonyPatch("TryActivateAnimatedHands")]
		private static bool DisableAnimatedHands(Tool __instance, Player expectedHolder, ref bool __result)
		{
			if (!Plugin.VREnabled)
			{
				return true;
			}
			try
			{
				if ((Object)(object)expectedHolder == (Object)null || ((NetworkBehaviour)expectedHolder).Owner == (NetworkConnection)null || !((NetworkBehaviour)expectedHolder).Owner.IsLocalClient)
				{
					return true;
				}
			}
			catch
			{
				return true;
			}
			try
			{
				if ((Object)(object)__instance.HandsMesh != (Object)null)
				{
					__instance.HandsMesh.enabled = false;
				}
			}
			catch
			{
			}
			__result = false;
			return false;
		}
	}
	[HarmonyPatch(typeof(PlayerToolMovement))]
	internal static class AimAnimationPatches
	{
		[HarmonyPrefix]
		[HarmonyPatch("SetAimPos")]
		private static void KillAimPose(PlayerToolMovement __instance, ref Vector3 aimPos)
		{
			//IL_0044: 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)
			if (!Plugin.VREnabled)
			{
				return;
			}
			try
			{
				if ((Object)(object)__instance._player == (Object)null || ((NetworkBehaviour)__instance._player).Owner == (NetworkConnection)null || !((NetworkBehaviour)__instance._player).Owner.IsLocalClient)
				{
					return;
				}
			}
			catch
			{
				return;
			}
			aimPos = Vector3.zero;
		}
	}
	[HarmonyPatch(typeof(PlayerHolding))]
	internal static class HeldItemHoldPatches
	{
		internal static bool ShouldHandHold(PlayerHolding h)
		{
			if (!Plugin.VREnabled || !Plugin.HeadsetActive)
			{
				return false;
			}
			try
			{
				if ((Object)(object)h._player == (Object)null || ((NetworkBehaviour)h._player).Owner == (NetworkConnection)null || !((NetworkBehaviour)h._player).Owner.IsLocalClient)
				{
					return false;
				}
				if (Boat.IsDrivingLocally)
				{
					return false;
				}
				Item heldItem = h._heldItem;
				if ((Object)(object)heldItem == (Object)null || (Object)(object)heldItem.Tool != (Object)null)
				{
					return false;
				}
				if (heldItem is Explosive)
				{
					return false;
				}
				return true;
			}
			catch
			{
				return false;
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch("CalculateHoldTargetPos")]
		private static void HandHoldPos(PlayerHolding __instance, ref Vector3 __result)
		{
			//IL_0016: 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)
			if (ShouldHandHold(__instance) && TryGetHandHoldTarget(__instance, out var position, out var _))
			{
				__result = position;
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch("CalculateHoldTargetRot")]
		private static void HandHoldRot(PlayerHolding __instance, ref Quaternion __result)
		{
			//IL_0016: 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)
			if (ShouldHandHold(__instance) && TryGetHandHoldTarget(__instance, out var _, out var rotation))
			{
				__result = rotation;
			}
		}

		private static bool TryGetHandHoldTarget(PlayerHolding h, out Vector3 position, out Quaternion rotation)
		{
			//IL_0001: 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_000d: 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_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: 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_0138: 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_0145: Unknown result type (might be due to invalid IL or missing references)
			//IL_014a: 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_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: 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_00da: 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_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: 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_012d: Unknown result type (might be due to invalid IL or missing references)
			position = default(Vector3);
			rotation = Quaternion.identity;
			try
			{
				VRRig instance = VRRig.Instance;
				Item val = (((Object)(object)h != (Object)null) ? h._heldItem : null);
				if ((Object)(object)instance == (Object)null || (Object)(object)instance.MainHand == (Object)null || (Object)(object)val == (Object)null || (Object)(object)((Component)val).transform == (Object)null)
				{
					return false;
				}
				Quaternion rightGripOffset = PlayerHandsPatches.RightGripOffset;
				Quaternion val2 = instance.MainHand.rotation * rightGripOffset;
				HandTransforms handTransformsRight = val.HandTransformsRight;
				if (handTransformsRight != null && handTransformsRight.Exists)
				{
					Transform obj = (((Object)(object)handTransformsRight.Parent != (Object)null) ? handTransformsRight.Parent : ((Component)val).transform);
					Vector3 val3 = obj.TransformPoint(handTransformsRight.HandPos);
					Quaternion val4 = obj.rotation * handTransformsRight.HandRot;
					Vector3 val5 = ((Component)val).transform.InverseTransformPoint(val3);
					Quaternion val6 = Quaternion.Inverse(((Component)val).transform.rotation) * val4;
					rotation = val2 * Quaternion.Inverse(val6);
					position = instance.MainHand.position - rotation * val5;
					return true;
				}
				rotation = val2;
				position = instance.MainHand.position;
				return true;
			}
			catch
			{
				return false;
			}
		}
	}
	[HarmonyPatch(typeof(PlayerHolding))]
	internal static class HeldItemPatches
	{
		[HarmonyPrefix]
		[HarmonyPatch("MoveItemToHoldPosRot")]
		private static bool SkipGameHold(PlayerHolding __instance)
		{
			if (!Plugin.VREnabled)
			{
				return true;
			}
			try
			{
				Item heldItem = __instance.HeldItem;
				if ((Object)(object)heldItem == (Object)null || (Object)(object)heldItem.Tool != (Object)null)
				{
					return true;
				}
				Player player = __instance._player;
				if ((Object)(object)player == (Object)null || ((NetworkBehaviour)player).Owner == (NetworkConnection)null)
				{
					return true;
				}
				if (((NetworkBehaviour)player).Owner.IsLocalClient)
				{
					if (!Plugin.HeadsetActive)
					{
						return true;
					}
					return HeldItemHoldPatches.ShouldHandHold(__instance);
				}
				try
				{
					if ((Object)(object)player.Other != (Object)null && player.Other.OnBoat)
					{
						return true;
					}
					if ((Object)(object)((NetworkBehaviour)player).NetworkObject != (Object)null && VRNetSync.TryGetPose(((NetworkBehaviour)player).NetworkObject.ObjectId, out var pose) && pose.Held && !pose.HeldIsTool)
					{
						return false;
					}
				}
				catch
				{
				}
				return true;
			}
			catch
			{
				return true;
			}
		}
	}
	[HarmonyPatch(typeof(PlayerInventory))]
	internal static class InventoryPatches
	{
		private const float Flick = 0.7f;

		private const float Interval = 0.3f;

		private static float _last = -10f;

		[HarmonyPrefix]
		[HarmonyPatch("ScrollSlotInput")]
		private static bool DiscreteScroll(CallbackContext context)
		{
			if (!Plugin.VREnabled)
			{
				return true;
			}
			return false;
		}
	}
	[HarmonyPatch(typeof(PlayerCamera))]
	internal static class PlayerCameraPatches
	{
		[HarmonyPostfix]
		[HarmonyPatch("OnStartClient")]
		private static void OnStart(PlayerCamera __instance)
		{
			if (!Plugin.VREnabled)
			{
				return;
			}
			try
			{
				PlayerCamera.SetViewBobbing(false);
			}
			catch
			{
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch("SetCamPosRot")]
		private static void SyncRotY(PlayerCamera __instance)
		{
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: 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_0087: 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)
			if (!Plugin.VREnabled)
			{
				return;
			}
			try
			{
				VRRig instance = VRRig.Instance;
				VRActions instance2 = VRActions.Instance;
				if (!((Object)(object)instance == (Object)null) && instance2 != null && !((Object)(object)instance.Root == (Object)null) && instance.IsCalibrated)
				{
					Transform camTransform = __instance.CamTransform;
					if (!((Object)(object)camTransform == (Object)null))
					{
						float num = (((Object)(object)camTransform.parent != (Object)null) ? camTransform.parent.eulerAngles.y : 0f);
						Quaternion val = instance.Root.rotation * instance2.HeadRot;
						float y = ((Quaternion)(ref val)).eulerAngles.y;
						__instance._rot.y = Mathf.DeltaAngle(num, y);
					}
				}
			}
			catch
			{
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch("MouseInput")]
		private static bool BlockMouseLook()
		{
			return !Plugin.VREnabled;
		}

		[HarmonyPostfix]
		[HarmonyPatch("SetCamPosRot")]
		private static void HeadTrackForGameLogic(PlayerCamera __instance)
		{
			//IL_0053: 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_0063: 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)
			if (!Plugin.VREnabled)
			{
				return;
			}
			try
			{
				VRRig instance = VRRig.Instance;
				VRActions instance2 = VRActions.Instance;
				if (!((Object)(object)instance == (Object)null) && instance2 != null && !((Object)(object)instance.Root == (Object)null) && instance.IsCalibrated)
				{
					Transform camTransform = __instance.CamTransform;
					if (!((Object)(object)camTransform == (Object)null))
					{
						camTransform.SetPositionAndRotation(instance.Root.TransformPoint(instance2.HeadPos), instance.Root.rotation * instance2.HeadRot);
					}
				}
			}
			catch
			{
			}
		}
	}
	[HarmonyPatch(typeof(PlayerDeathCam))]
	internal static class PlayerDeathCamPatches
	{
		[HarmonyPostfix]
		[HarmonyPatch("EnableDeathCam")]
		private static void StayFirstPerson(PlayerDeathCam __instance)
		{
			if (!Plugin.VREnabled)
			{
				return;
			}
			Player player = __instance._player;
			if (!((Object)(object)player == (Object)null))
			{
				Camera deathCam = __instance._deathCam;
				if ((Object)(object)deathCam != (Object)null)
				{
					((Behaviour)deathCam).enabled = false;
				}
				Camera val = (((Object)(object)player.Camera != (Object)null) ? player.Camera.Cam : null);
				if ((Object)(object)val != (Object)null)
				{
					player.SetCurCam(val);
				}
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch("OrbitCamera")]
		private static bool SkipOrbit()
		{
			return !Plugin.VREnabled;
		}
	}
	[HarmonyPatch(typeof(DeathUI))]
	internal static class DeathUIPatches
	{
		[HarmonyPostfix]
		[HarmonyPatch("ToggleDeathUI")]
		private static void PreservePanelScale(DeathUI __instance, bool to)
		{
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Invalid comparison between Unknown and I4
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			if (!Plugin.VREnabled)
			{
				return;
			}
			try
			{
				CanvasGroup deathCanvas = __instance._deathCanvas;
				if ((Object)(object)deathCanvas == (Object)null)
				{
					return;
				}
				Canvas componentInParent = ((Component)deathCanvas).GetComponentInParent<Canvas>(true);
				if (!((Object)(object)componentInParent == (Object)null))
				{
					VRUIManager.Instance?.SyncDeathOverlay(__instance, to);
					if ((int)componentInParent.renderMode == 2)
					{
						LeanTween.cancel(((Component)deathCanvas).gameObject);
						((Component)deathCanvas).transform.localScale = Vector3.one;
						deathCanvas.alpha = (to ? 1f : 0f);
					}
				}
			}
			catch
			{
			}
		}
	}
	[HarmonyPatch(typeof(PlayerHands))]
	internal static class PlayerHandsPatches
	{
		internal static readonly Quaternion RightGripOffset = Quaternion.Euler(-25f, 0f, 0f) * Quaternion.Euler(180f, 90f, 0f) * Quaternion.Euler(0f, 180f, 0f);

		internal static readonly Quaternion LeftGripOffset = MirrorAcrossSagittalPlane(RightGripOffset) * Quaternion.Euler(0f, 180f, 0f);

		private static readonly Vector3 RightHandPositionOffset = new Vector3(0.02260734f, 0.02081691f, 0.001267433f);

		private static readonly Vector3 LeftHandPositionOffset = new Vector3(-0.02260734f, 0.02081691f, 0.001267433f);

		private static bool _slapRestInit;

		private static Vector3 _slapRestPos;

		internal static Vector3 CalibratedHandPosition(Transform controller, bool isLeft)
		{
			//IL_0009: 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_0012: 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_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_002b: 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)
			if ((Object)(object)controller == (Object)null)
			{
				return Vector3.zero;
			}
			Vector3 val = (isLeft ? LeftHandPositionOffset : RightHandPositionOffset);
			return controller.position + controller.rotation * val;
		}

		private static Quaternion MirrorAcrossSagittalPlane(Quaternion q)
		{
			//IL_0000: 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_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: 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)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			return Quaternion.Normalize(new Quaternion(q.x, 0f - q.y, 0f - q.z, q.w));
		}

		[HarmonyPostfix]
		[HarmonyPatch("LateUpdate")]
		private static void PlaceHands(PlayerHands __instance)
		{
			ApplyTrackedHands(__instance);
		}

		internal static void ApplyTrackedHands(PlayerHands __instance)
		{
			//IL_033c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0343: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_031e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0320: Unknown result type (might be due to invalid IL or missing references)
			//IL_0322: Unknown result type (might be due to invalid IL or missing references)
			//IL_0329: Unknown result type (might be due to invalid IL or missing references)
			//IL_030b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0315: Unknown result type (might be due to invalid IL or missing references)
			//IL_031a: 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_0129: Unknown result type (might be due to invalid IL or missing references)
			//IL_012e: 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_015f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0166: 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_01ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_039c: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0439: Unknown result type (might be due to invalid IL or missing references)
			//IL_043e: Unknown result type (might be due to invalid IL or missing references)
			//IL_03eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0291: 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_02d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02da: Unknown result type (might be due to invalid IL or missing references)
			if (!Plugin.HeadsetActive)
			{
				return;
			}
			try
			{
				if ((Object)(object)__instance._player == (Object)null || ((NetworkBehaviour)__instance._player).Owner == (NetworkConnection)null || !((NetworkBehaviour)__instance._player).Owner.IsLocalClient)
				{
					return;
				}
			}
			catch
			{
				return;
			}
			try
			{
				if (Boat.IsDrivingLocally)
				{
					return;
				}
			}
			catch
			{
			}
			VRRig instance = VRRig.Instance;
			if ((Object)(object)instance == (Object)null || (Object)(object)instance.LeftHand == (Object)null)
			{
				return;
			}
			bool flag = false;
			try
			{
				flag = (Object)(object)__instance._player != (Object)null && (Object)(object)__instance._player.Holding != (Object)null && (Object)(object)__instance._player.Holding.HeldItem != (Object)null;
			}
			catch
			{
			}
			if (!flag)
			{
				PlayerToolMovementPatches.ClearGripTargets();
			}
			Transform handBoneRight = __instance.HandBoneRight;
			Transform handBoneLeft = __instance.HandBoneLeft;
			if ((Object)(object)handBoneRight != (Object)null)
			{
				handBoneRight.position = CalibratedHandPosition(instance.RightHand, isLeft: false);
				handBoneRight.rotation = instance.RightHand.rotation * RightGripOffset;
			}
			if ((Object)(object)handBoneLeft != (Object)null)
			{
				handBoneLeft.position = CalibratedHandPosition(instance.LeftHand, isLeft: true);
				handBoneLeft.rotation = instance.LeftHand.rotation * LeftGripOffset;
			}
			Transform offHandGripTarget = PlayerToolMovementPatches.OffHandGripTarget;
			if ((Object)(object)offHandGripTarget != (Object)null)
			{
				Transform val = handBoneLeft;
				if ((Object)(object)val != (Object)null)
				{
					val.SetPositionAndRotation(offHandGripTarget.position, offHandGripTarget.rotation);
				}
			}
			Transform mainHandGripTarget = PlayerToolMovementPatches.MainHandGripTarget;
			if ((Object)(object)mainHandGripTarget != (Object)null)
			{
				if (!((Component)mainHandGripTarget).gameObject.activeInHierarchy)
				{
					PlayerToolMovementPatches.ClearGripTargets();
				}
				else
				{
					Transform val2 = handBoneRight;
					if ((Object)(object)val2 != (Object)null)
					{
						val2.SetPositionAndRotation(mainHandGripTarget.position, mainHandGripTarget.rotation);
					}
				}
			}
			try
			{
				Item val3 = (((Object)(object)__instance._player != (Object)null && (Object)(object)__instance._player.Holding != (Object)null) ? __instance._player.Holding.HeldItem : null);
				if (!((Object)(object)val3 != (Object)null) || !((Object)(object)val3.Tool == (Object)null))
				{
					return;
				}
				if (VRHeldItem.FishTwoHand)
				{
					DeadPlayer val4 = (DeadPlayer)(object)((val3 is DeadPlayer) ? val3 : null);
					if (val4 != null && (Object)(object)val4._slapHandAnim != (Object)null && val4._isResurrecting && (Object)(object)((Component)val4._slapHandAnim).transform != (Object)null)
					{
						Transform val5 = handBoneLeft;
						Transform transform = ((Component)val4._slapHandAnim).transform;
						if (!((Object)(object)val5 != (Object)null) || !((Object)(object)transform != (Object)null))
						{
							return;
						}
						if (!_slapRestInit)
						{
							_slapRestPos = transform.position;
							_slapRestInit = true;
						}
						Vector3 val6 = Vector3.zero;
						bool flag2 = false;
						try
						{
							HandTransforms handTransformsLeft = val3.HandTransformsLeft;
							if (handTransformsLeft != null && (Object)(object)handTransformsLeft.Parent != (Object)null)
							{
								val6 = handTransformsLeft.Parent.TransformPoint(handTransformsLeft.HandPos);
								flag2 = true;
							}
						}
						catch
						{
						}
						if (flag2)
						{
							Vector3 val7 = transform.position - _slapRestPos;
							if (((Vector3)(ref val7)).magnitude > 0.35f)
							{
								val7 = ((Vector3)(ref val7)).normalized * 0.35f;
							}
							val5.SetPositionAndRotation(val6 + val7, transform.rotation);
						}
						else
						{
							val5.SetPositionAndRotation(transform.position, transform.rotation);
						}
						return;
					}
				}
				if (VRHeldItem.FishTwoHand)
				{
					_slapRestInit = false;
					if ((Object)(object)handBoneRight != (Object)null && val3.HandTransformsRight != null && (Object)(object)val3.HandTransformsRight.Parent != (Object)null)
					{
						handBoneRight.position = val3.HandTransformsRight.Parent.TransformPoint(val3.HandTransformsRight.HandPos);
					}
					if ((Object)(object)handBoneLeft != (Object)null && val3.HandTransformsLeft != null && (Object)(object)val3.HandTransformsLeft.Parent != (Object)null)
					{
						handBoneLeft.position = val3.HandTransformsLeft.Parent.TransformPoint(val3.HandTransformsLeft.HandPos);
					}
				}
				else
				{
					Transform val8 = handBoneRight;
					HandTransforms handTransformsRight = val3.HandTransformsRight;
					if (handTransformsRight != null && handTransformsRight.Exists && (Object)(object)handTransformsRight.Parent != (Object)null && (Object)(object)val8 != (Object)null)
					{
						val8.position = handTransformsRight.Parent.TransformPoint(handTransformsRight.HandPos);
					}
				}
			}
			catch
			{
			}
		}
	}
	[HarmonyPatch(typeof(Player))]
	internal static class PlayerPatches
	{
		[HarmonyPostfix]
		[HarmonyPatch("LateUpdate")]
		private static void HmdMovementYaw(Player __instance)
		{
			//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_004e: 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_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)
			if (Plugin.VREnabled && !((Object)(object)__instance != (Object)(object)Player.LocalPlayer))
			{
				VRRig instance = VRRig.Instance;
				VRActions instance2 = VRActions.Instance;
				if (!((Object)(object)instance == (Object)null) && !((Object)(object)instance.Root == (Object)null) && instance2 != null)
				{
					Quaternion val = instance.Root.rotation * instance2.HeadRot;
					float y = ((Quaternion)(ref val)).eulerAngles.y;
					__instance.CurPlayerRot = Quaternion.Euler(0f, y, 0f);
				}
			}
		}
	}
	[HarmonyPatch(typeof(PlayerToolMovement))]
	internal static class PlayerToolMovementPatches
	{
		private static readonly Quaternion ToolRotOffset = Quaternion.Euler(45f, 0f, 0f);

		private const float ForegripDistance = 0.24f;

		private const float ForegripLatchRadius = 0.2f;

		private const float RodLatchRadius = 0.5f;

		private const float MinTwoHandAimSpan = 0.15f;

		private const float TwoHandAimFollow = 35f;

		private const float SupportSteeringGain = 1.06f;

		private static bool _gunTwoHand;

		private static bool _rodTwoHand;

		private static readonly Vector3[] _fistFromHandPos = (Vector3[])(object)new Vector3[2];

		private static readonly Quaternion[] _fistFromHandRot = (Quaternion[])(object)new Quaternion[2]
		{
			Quaternion.identity,
			Quaternion.identity
		};

		private static readonly bool[] _fistFromHandValid = new bool[2];

		private static Melee _fistPoseTool;

		private static Item _twoHandTool;

		private static Quaternion _twoHandAimRotation = Quaternion.identity;

		private static bool _twoHandAimValid;

		private static Quaternion _twoHandGrabOffset = Quaternion.identity;

		private static bool _twoHandGrabOffsetValid;

		private static Vector3 _toolPos;

		private static Quaternion _toolRot;

		private static bool _toolInit;

		private static Vector3 _recoilRestPos;

		private static Quaternion _recoilRestRot;

		private static bool _recoilInit;

		private static PlayerToolMovement _recoilLastOwner;

		private static Item _recoilLastTool;

		public static bool RodTwoHand => _rodTwoHand;

		public static bool GunTwoHand => _gunTwoHand;

		public static Transform OffHandGripTarget { get; private set; }

		public static Transform MainHandGripTarget { get; private set; }

		public static void ClearGripTargets()
		{
			OffHandGripTarget = null;
			MainHandGripTarget = null;
		}

		[HarmonyPostfix]
		[HarmonyPatch("GlueToCamera")]
		private static void FollowHand(PlayerToolMovement __instance)
		{
			//IL_0156: Unknown result type (might be due to invalid IL or missing references)
			//IL_015b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0147: 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_0222: Expected O, but got Unknown
			//IL_02a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0281: Unknown result type (might be due to invalid IL or missing references)
			//IL_0283: Unknown result type (might be due to invalid IL or missing references)
			//IL_028d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0292: Unknown result type (might be due to invalid IL or missing references)
			//IL_04aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_04b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_04bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_04c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_04c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_04cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_04a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_04a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0160: Unknown result type (might be due to invalid IL or missing references)
			//IL_0163: 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_016d: 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_0175: Unknown result type (might be due to invalid IL or missing references)
			//IL_0189: Unknown result type (might be due to invalid IL or missing references)
			//IL_018e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0193: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_04fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_04fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0501: Unknown result type (might be due to invalid IL or missing references)
			//IL_0506: Unknown result type (might be due to invalid IL or missing references)
			//IL_0508: Unknown result type (might be due to invalid IL or missing references)
			//IL_050a: Unknown result type (might be due to invalid IL or missing references)
			//IL_050c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0511: Unknown result type (might be due to invalid IL or missing references)
			//IL_0516: Unknown result type (might be due to invalid IL or missing references)
			//IL_04d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_04d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_04db: Unknown result type (might be due to invalid IL or missing references)
			//IL_04dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_04e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c5: 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_01d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01db: Unknown result type (might be due to invalid IL or missing references)
			//IL_05a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_05a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_058e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0593: Unknown result type (might be due to invalid IL or missing references)
			//IL_0597: Unknown result type (might be due to invalid IL or missing references)
			//IL_059c: Unknown result type (might be due to invalid IL or missing references)
			//IL_055c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0561: Unknown result type (might be due to invalid IL or missing references)
			//IL_0566: Unknown result type (might be due to invalid IL or missing references)
			//IL_0568: Unknown result type (might be due to invalid IL or missing references)
			//IL_056d: 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_030f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0311: Unknown result type (might be due to invalid IL or missing references)
			//IL_0313: Unknown result type (might be due to invalid IL or missing references)
			//IL_0315: Unknown result type (might be due to invalid IL or missing references)
			//IL_031a: Unknown result type (might be due to invalid IL or missing references)
			//IL_031f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0321: Unknown result type (might be due to invalid IL or missing references)
			//IL_0323: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f4: 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_01f8: 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_01ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_05b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_05bc: 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_05d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_05d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_05d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_05da: Unknown result type (might be due to invalid IL or missing references)
			//IL_05df: Unknown result type (might be due to invalid IL or missing references)
			//IL_05d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_05e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_05e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_05e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_05ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_05ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_06f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_06f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_062f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0634: Unknown result type (might be due to invalid IL or missing references)
			//IL_063b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0640: Unknown result type (might be due to invalid IL or missing references)
			//IL_0657: Unknown result type (might be due to invalid IL or missing references)
			//IL_065c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0663: Unknown result type (might be due to invalid IL or missing references)
			//IL_0668: Unknown result type (might be due to invalid IL or missing references)
			//IL_066d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0671: Unknown result type (might be due to invalid IL or missing references)
			//IL_0676: Unknown result type (might be due to invalid IL or missing references)
			//IL_067b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0680: Unknown result type (might be due to invalid IL or missing references)
			//IL_06cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_06cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_06d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_06d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_06d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_06da: Unknown result type (might be due to invalid IL or missing references)
			//IL_06dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_06de: Unknown result type (might be due to invalid IL or missing references)
			//IL_06e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_06e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0692: Unknown result type (might be due to invalid IL or missing references)
			//IL_0697: Unknown result type (might be due to invalid IL or missing references)
			//IL_040d: Unknown result type (might be due to invalid IL or missing references)
			//IL_040f: Unknown result type (might be due to invalid IL or missing references)
			//IL_06a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_06ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_06b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_06ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_06bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_06c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_06c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_06cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_041b: Unknown result type (might be due to invalid IL or missing references)
			//IL_041d: Unknown result type (might be due to invalid IL or missing references)
			//IL_041f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0424: Unknown result type (might be due to invalid IL or missing references)
			//IL_0437: Unknown result type (might be due to invalid IL or missing references)
			//IL_043c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0485: Unknown result type (might be due to invalid IL or missing references)
			//IL_0487: Unknown result type (might be due to invalid IL or missing references)
			//IL_0489: Unknown result type (might be due to invalid IL or missing references)
			//IL_048e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0473: Unknown result type (might be due to invalid IL or missing references)
			//IL_0478: Unknown result type (might be due to invalid IL or missing references)
			//IL_047d: Unknown result type (might be due to invalid IL or missing references)
			if (!Plugin.HeadsetActive)
			{
				return;
			}
			try
			{
				if ((Object)(object)__instance._player == (Object)null || ((NetworkBehaviour)__instance._player).Owner == (NetworkConnection)null || !((NetworkBehaviour)__instance._player).Owner.IsLocalClient)
				{
					return;
				}
			}
			catch
			{
				return;
			}
			try
			{
				if (Boat.IsDrivingLocally)
				{
					_gunTwoHand = false;
					_rodTwoHand = false;
					_toolInit = false;
					_recoilInit = false;
					ClearGripTargets();
					return;
				}
			}
			catch
			{
			}
			VRRig instance = VRRig.Instance;
			if ((Object)(object)instance == (Object)null)
			{
				return;
			}
			Tool currentTool = __instance.CurrentTool;
			if ((Object)(object)currentTool == (Object)null || (Object)(object)((Component)currentTool).transform == (Object)null)
			{
				_gunTwoHand = false;
				_rodTwoHand = false;
				_toolInit = false;
				_twoHandTool = null;
				_twoHandAimValid = false;
				_twoHandGrabOffsetValid = false;
				ClearGripTargets();
				return;
			}
			if ((Object)(object)_twoHandTool != (Object)(object)currentTool)
			{
				_twoHandTool = (Item)(object)currentTool;
				_twoHandAimValid = false;
				_twoHandGrabOffsetValid = false;
				_gunTwoHand = false;
			}
			Transform mainHand = instance.MainHand;
			Transform offHand = instance.OffHand;
			if ((Object)(object)mainHand == (Object)null || (Object)(object)offHand == (Object)null)
			{
				return;
			}
			Weapon weapon = ((Item)currentTool).Weapon;
			bool flag = currentTool is FishingRod;
			Transform val = null;
			try
			{
				val = ((Item)currentTool).HandModelRight;
			}
			catch
			{
			}
			bool flag2 = (Object)(object)val != (Object)null;
			Vector3 val2 = (flag2 ? ((Component)currentTool).transform.InverseTransformPoint(val.position) : Vector3.zero);
			Quaternion val3 = mainHand.rotation * ToolRotOffset;
			Vector3 val4 = mainHand.rotation * new Vector3(0f, -0.035f, -0.03f);
			bool isLeft = (Object)(object)mainHand == (Object)(object)instance.LeftHand;
			bool isLeft2 = (Object)(object)offHand == (Object)(object)instance.LeftHand;
			bool num = (Object)(object)weapon != (Object)null || flag;
			Vector3 val5 = (num ? PlayerHandsPatches.CalibratedHandPosition(mainHand, isLeft) : (mainHand.position + val4));
			Vector3 val6 = (num ? PlayerHandsPatches.CalibratedHandPosition(offHand, isLeft2) : offHand.position);
			Vector3 val7 = (flag2 ? (val5 - val3 * val2) : val5);
			Transform val8 = null;
			try
			{
				val8 = ((Item)currentTool).HandModelLeft;
			}
			catch
			{
			}
			if (flag)
			{
				try
				{
					FishingRod val9 = (FishingRod)currentTool;
					if ((Object)(object)val9._crankHandleHandHolder != (Object)null)
					{
						val8 = val9._crankHandleHandHolder;
					}
					else if ((Object)(object)val9._crankHandle != (Object)null)
					{
						val8 = val9._crankHandle;
					}
					else if ((Object)(object)val9._crank != (Object)null)
					{
						val8 = val9._crank;
					}
				}
				catch
				{
				}
			}
			bool flag3 = (Object)(object)val8 != (Object)null;
			Vector3 val10 = (flag3 ? ((Component)currentTool).transform.InverseTransformPoint(val8.position) : (val2 + Vector3.forward * 0.24f));
			float num2 = (((Object)(object)offHand == (Object)(object)instance.LeftHand) ? VRActions.Instance.LeftGrip.ReadValue<float>() : VRActions.Instance.RightGrip.ReadValue<float>());
			float value = VRConfig.GripThreshold.Value;
			float num3 = Mathf.Max(0.05f, value - 0.2f);
			float num4 = (flag ? 0.5f : 0.2f);
			Vector3 val11 = val7 + val3 * val10;
			bool flag4 = Vector3.Distance(val6, val11) <= num4;
			bool gunTwoHand = _gunTwoHand;
			if ((Object)(object)weapon != (Object)null)
			{
				if (!_gunTwoHand)
				{
					if (num2 >= value && flag4)
					{
						_gunTwoHand = true;
					}
				}
				else if (num2 < num3)
				{
					_gunTwoHand = false;
					_twoHandAimValid = false;
					_twoHandGrabOffsetValid = false;
				}
				if (!gunTwoHand && _gunTwoHand)
				{
					_twoHandGrabOffsetValid = false;
				}
				weapon._holdingAdsInput = _gunTwoHand;
			}
			else
			{
				_gunTwoHand = false;
				_twoHandAimValid = false;
				_twoHandGrabOffsetValid = false;
			}
			if (flag)
			{
				if (!_rodTwoHand)
				{
					if (num2 >= value && flag4)
					{
						_rodTwoHand = true;
					}
				}
				else if (num2 < num3)
				{
					_rodTwoHand = false;
				}
			}
			else
			{
				_rodTwoHand = false;
			}
			OffHandGripTarget = ((_gunTwoHand || _rodTwoHand) ? val8 : null);
			MainHandGripTarget = ((flag2 && !(currentTool is Melee)) ? val : null);
			Quaternion val12 = val3;
			if (_gunTwoHand)
			{
				Vector3 val13 = val6 - val5;
				if (((Vector3)(ref val13)).magnitude >= 0.15f)
				{
					Vector3 val14 = Vector3.forward;
					try
					{
						if ((Object)(object)weapon.Attachments != (Object)null && (Object)(object)weapon.Attachments.FirePoint != (Object)null)
						{
							val14 = ((Component)currentTool).transform.InverseTransformDirection(weapon.Attachments.FirePoint.forward);
						}
						else if (flag3)
						{
							val14 = val10 - val2;
						}
					}
					catch
					{
					}
					if (((Vector3)(ref val14)).sqrMagnitude < 1E-06f)
					{
						val14 = Vector3.forward;
					}
					Quaternion val15 = Quaternion.FromToRotation(val3 * ((Vector3)(ref val14)).normalized, ((Vector3)(ref val13)).normalized) * val3;
					if (!_twoHandGrabOffsetValid)
					{
						_twoHandGrabOffset = Quaternion.Inverse(val15) * val3;
						_twoHandGrabOffsetValid = true;
						_twoHandAimRotation = val3;
						_twoHandAimValid = true;
					}
					Quaternion val16 = val15 * _twoHandGrabOffset;
					Quaternion val17 = val16 * Quaternion.Inverse(val3);
					float num5 = default(float);
					Vector3 val18 = default(Vector3);
					((Quaternion)(ref val17)).ToAngleAxis(ref num5, ref val18);
					if (num5 > 180f)
					{
						num5 -= 360f;
					}
					if (((Vector3)(ref val18)).sqrMagnitude > 1E-06f && Mathf.Abs(num5) > 0.001f)
					{
						val16 = Quaternion.AngleAxis(num5 * 1.06f, ((Vector3)(ref val18)).normalized) * val3;
					}
					if (_twoHandAimValid)
					{
						float num6 = 1f - Mathf.Exp(-35f * Time.unscaledDeltaTime);
						_twoHandAimRotation = Quaternion.Slerp(_twoHandAimRotation, val16, num6);
					}
					else
					{
						_twoHandAimRotation = val16;
						_twoHandAimValid = true;
					}
				}
				if (_twoHandAimValid)
				{
					val12 = _twoHandAimRotation;
				}
			}
			else
			{
				_twoHandAimValid = false;
				_twoHandGrabOffsetValid = false;
			}
			Vector3 val19 = (flag2 ? (val5 - val12 * val2) : val5);
			Vector3 val20 = val19;
			Quaternion val21 = val12;
			Rigidbody toolRecoilRig = __instance._toolRecoilRig;
			if ((Object)(object)toolRecoilRig != (Object)null)
			{
				Transform transform = ((Component)toolRecoilRig).transform;
				if (!_recoilInit || (Object)(object)_recoilLastOwner != (Object)(object)__instance || (Object)(object)_recoilLastTool != (Object)(object)currentTool)
				{
					_recoilRestPos = transform.localPosition;
					_recoilRestRot = transform.localRotation;
					_recoilInit = true;
					_recoilLastOwner = __instance;
					_recoilLastTool = (Item)(object)currentTool;
				}
				Quaternion val22 = Quaternion.Inverse(_recoilRestRot) * transform.localRotation;
				Vector3 val23 = transform.localPosition - _recoilRestPos;
				if (((Vector3)(ref val23)).magnitude < 0.002f)
				{
					Vector3 eulerAngles = ((Quaternion)(ref val22)).eulerAngles;
					if (((Vector3)(ref eulerAngles)).magnitude < 1f)
					{
						_recoilRestPos = transform.localPosition;
						_recoilRestRot = transform.localRotation;
						val22 = Quaternion.identity;
						val23 = Vector3.zero;
					}
				}
				val21 = val12 * val22;
				val20 = val19 + val21 * val23;
			}
			((Component)currentTool).transform.SetPositionAndRotation(val20, val21);
			Melee val24 = (Melee)(object)((currentTool is Melee) ? currentTool : null);
			if (val24 != null)
			{
				PinTwoHandMeleeFists(val24);
			}
		}

		internal static void PinTwoHandMeleeFists(Melee melee)
		{
			//IL_0161: Unknown result type (might be due to invalid IL or missing references)
			//IL_0166: Unknown result type (might be due to invalid IL or missing references)
			//IL_016b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0174: Unknown result type (might be due to invalid IL or missing references)
			//IL_017b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0180: 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_0195: Unknown result type (might be due to invalid IL or missing references)
			//IL_019a: 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_01a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b9: 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)
			//IL_01c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01db: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e6: 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_01ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0214: Unknown result type (might be due to invalid IL or missing references)
			//IL_020d: 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_021d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0222: Unknown result type (might be due to invalid IL or missing references)
			//IL_0224: Unknown result type (might be due to invalid IL or missing references)
			//IL_0229: Unknown result type (might be due to invalid IL or missing references)
			//IL_022f: 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_023c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0241: 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_024b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0253: Unknown result type (might be due to invalid IL or missing references)
			//IL_0258: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if ((Object)(object)melee == (Object)null || !melee._useBothHands || melee._hands == null || melee._hands.Length < 2)
				{
					return;
				}
				try
				{
					if ((Object)(object)((Item)melee).Holder == (Object)null || ((NetworkBehaviour)((Item)melee).Holder).Owner == (NetworkConnection)null || !((NetworkBehaviour)((Item)melee).Holder).Owner.IsLocalClient)
					{
						return;
					}
				}
				catch
				{
					return;
				}
				VRRig instance = VRRig.Instance;
				if ((Object)(object)instance == (Object)null || (Object)(object)instance.LeftHand == (Object)null || (Object)(object)instance.RightHand == (Object)null)
				{
					return;
				}
				if ((Object)(object)_fistPoseTool != (Object)(object)melee)
				{
					_fistPoseTool = melee;
					_fistFromHandValid[0] = (_fistFromHandValid[1] = false);
				}
				for (int i = 0; i < 2; i++)
				{
					bool flag = i == 1;
					Transform val = (flag ? instance.LeftHand : instance.RightHand);
					Transform val2 = melee._hands[i];
					HandTransforms val3 = (flag ? ((Item)melee).HandTransformsLeft : ((Item)melee).HandTransformsRight);
					if (!((Object)(object)val2 == (Object)null) && !((Object)(object)val == (Object)null) && val3 != null && val3.Exists && !((Object)(object)val3.Parent == (Object)null) && !((Object)(object)val2.parent == (Object)null))
					{
						if (!_fistFromHandValid[i])
						{
							Vector3 val4 = val3.Parent.TransformPoint(val3.HandPos);
							Quaternion val5 = val3.Parent.rotation * val3.HandRot;
							Vector3 val6 = val2.parent.TransformPoint(melee._origPos[i]);
							Quaternion val7 = val2.parent.rotation * melee._origRot[i];
							_fistFromHandPos[i] = Quaternion.Inverse(val5) * (val6 - val4);
							_fistFromHandRot[i] = Quaternion.Inverse(val5) * val7;
							_fistFromHandValid[i] = true;
						}
						if (_fistFromHandValid[i])
						{
							Quaternion val8 = (flag ? PlayerHandsPatches.LeftGripOffset : PlayerHandsPatches.RightGripOffset);
							Quaternion val9 = val.rotation * val8;
							val2.SetPositionAndRotation(val.position + val9 * _fistFromHandPos[i], val9 * _fistFromHandRot[i]);
						}
					}
				}
			}
			catch
			{
			}
		}
	}
	[HarmonyPatch(typeof(Melee), "LateUpdate")]
	internal static class VRMeleeVisualPatches
	{
		private static Melee _captured;

		private static readonly Vector3[] _positions = (Vector3[])(object)new Vector3[2];

		private static readonly Quaternion[] _rotations = (Quaternion[])(object)new Quaternion[2]
		{
			Quaternion.identity,
			Quaternion.identity
		};

		[HarmonyPrefix]
		private static void CaptureKnucklePose(Melee __instance)
		{
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			_captured = null;
			if (!Plugin.HeadsetActive || !IsLocalTwoFist(__instance))
			{
				return;
			}
			PlayerToolMovementPatches.PinTwoHandMeleeFists(__instance);
			for (int i = 0; i < 2; i++)
			{
				Transform val = __instance._hands[i];
				if ((Object)(object)val == (Object)null)
				{
					return;
				}
				_positions[i] = val.position;
				_rotations[i] = val.rotation;
			}
			_captured = __instance;
		}

		[HarmonyPostfix]
		private static void RestoreKnucklePose(Melee __instance)
		{
			//IL_0043: 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)
			if ((Object)(object)_captured != (Object)(object)__instance || __instance._hands == null || __instance._hands.Length < 2)
			{
				return;
			}
			for (int i = 0; i < 2; i++)
			{
				if ((Object)(object)__instance._hands[i] != (Object)null)
				{
					__instance._hands[i].SetPositionAndRotation(_positions[i], _rotations[i]);
				}
			}
			_captured = null;
		}

		private static bool IsLocalTwoFist(Melee melee)
		{
			try
			{
				return (Object)(object)melee != (Object)null && melee._useBothHands && melee._hands != null && melee._hands.Length >= 2 && (Object)(object)((Item)melee).Holder != (Object)null && ((NetworkBehaviour)((Item)melee).Holder).Owner != (NetworkConnection)null && ((NetworkBehaviour)((Item)melee).Holder).Owner.IsLocalClient;
			}
			catch
			{
				return false;
			}
		}
	}
	[HarmonyPatch]
	internal static class VRSprintItemPosePatches
	{
		[HarmonyPrefix]
		[HarmonyPatch(typeof(PlayerToolMovement), "SetSprintPos")]
		private static void NoSprintPosition(ref Vector3 sprintPos)
		{
			//IL_0008: 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)
			if (Plugin.HeadsetActive)
			{
				sprintPos = Vector3.zero;
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(PlayerToolMovement), "SetSprintRot")]
		private static void NoSprintRotation(ref Vector3 sprintRot)
		{
			//IL_0008: 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)
			if (Plugin.HeadsetActive)
			{
				sprintRot = Vector3.zero;
			}
		}
	}
	[HarmonyPatch]
	internal static class FishingRodAnimPatches
	{
		[HarmonyPrefix]
		[HarmonyPatch(typeof(FishingRod), "SetPullBackAnimation")]
		private static void NoPullBack(FishingRod __instance, ref float rodRot)
		{
			if (!Plugin.VREnabled)
			{
				return;
			}
			try
			{
				if ((Object)(object)((Item)__instance).Holder == (Object)null || ((NetworkBehaviour)((Item)__instance).Holder).Owner == (NetworkConnection)null || !((NetworkBehaviour)((Item)__instance).Holder).Owner.IsLocalClient)
				{
					return;
				}
			}
			catch
			{
				return;
			}
			rodRot = 0f;
		}
	}
	[HarmonyPatch]
	internal static class FishingReelPatches
	{
		[HarmonyPrefix]
		[HarmonyPatch(typeof(FishingRod), "PrimaryInput")]
		private static bool GateReel()
		{
			return true;
		}
	}
	[HarmonyPatch(typeof(FishingRod))]
	internal static class FishingPhysicalReelPatches
	{
		private const float CrankStartAngVel = 25f;

		private const float CrankFastAngVel = 380f;

		private const float MaxReelMulti = 4f;

		private static float _lastAngle;

		private static bool _angleValid;

		private static float _angVel;

		private static bool _wasCranking;

		private static bool _wasTwoHand;

		[HarmonyPrefix]
		[HarmonyPatch("FixedUpdate")]
		private static void PhysicalReel(FishingRod __instance)
		{
			//IL_0125: Unknown result type (might be due to invalid IL or missing references)
			//IL_012a: Unknown result type (might be due to invalid IL or missing references)
			//IL_012d: 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)
			//IL_0137: Unknown result type (might be due to invalid IL or missing references)
			//IL_0146: Unknown result type (might be due to invalid IL or missing references)
			//IL_014b: Unknown result type (might be due to invalid IL or missing references)
			//IL_014d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0152: 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_0156: Unknown result type (might be due to invalid IL or missing references)
			//IL_0158: Unknown result type (might be due to invalid IL or missing references)
			//IL_015a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0161: Unknown result type (might be due to invalid IL or missing references)
			//IL_0166: Unknown result type (might be due to invalid IL or missing references)
			//IL_016b: Unknown result type (might be due to invalid IL or missing references)
			//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_018c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0191: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ba: 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_01c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cc: 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_01a3: 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_026c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0271: Unknown result type (might be due to invalid IL or missing references)
			//IL_027e: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_029a: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ad: Unknown result type (might be due to invalid IL or missing references)
			if (!Plugin.VREnabled)
			{
				return;
			}
			bool rodTwoHand = PlayerToolMovementPatches.RodTwoHand;
			if (!rodTwoHand)
			{
				_angleValid = false;
				_wasCranking = false;
				_wasTwoHand = false;
				return;
			}
			try
			{
				Player holder = ((Item)__instance).Holder;
				if ((Object)(object)holder == (Object)null || ((NetworkBehaviour)holder).Owner == (NetworkConnection)null || !((NetworkBehaviour)holder).Owner.IsLocalClient)
				{
					_angleValid = false;
					_wasCranking = false;
					_wasTwoHand = false;
					return;
				}
			}
			catch
			{
				_angleValid = false;
				_wasCranking = false;
				_wasTwoHand = false;
				return;
			}
			VRRig instance = VRRig.Instance;
			if ((Object)(object)instance == (Object)null || (Object)(object)instance.OffHand == (Object)null || (Object)(object)instance.MainHand == (Object)null)
			{
				_angleValid = false;
				return;
			}
			Transform val = __instance._crank;
			if ((Object)(object)val == (Object)null)
			{
				val = __instance._crankHandle;
			}
			if ((Object)(object)val == (Object)null)
			{
				val = __instance._crankHandleHandHolder;
			}
			if ((Object)(object)val == (Object)null)
			{
				_angleValid = false;
				_wasCranking = false;
				_wasTwoHand = false;
				return;
			}
			if (!_wasTwoHand && rodTwoHand && __instance._isReelingOut)
			{
				FishingRodCast val2 = (FishingRodCast)(object)((__instance is FishingRodCast) ? __instance : null);
				if (val2 != null)
				{
					val2.StartReel();
				}
			}
			_wasTwoHand = rodTwoHand;
			Vector3 position = val.position;
			Vector3 val3 = val.TransformDirection(Vector3.forward);
			float num = 0f;
			Vector3 val4 = instance.OffHand.position - position;
			Vector3 val5 = val4 - val3 * Vector3.Dot(val4, val3);
			if (((Vector3)(ref val5)).sqrMagnitude >= 1E-06f)
			{
				((Vector3)(ref val5)).Normalize();
				Vector3 val6 = Vector3.Cross(val3, Vector3.up);
				if (((Vector3)(ref val6)).sqrMagnitude < 0.0001f)
				{
					val6 = Vector3.Cross(val3, Vector3.right);
				}
				((Vector3)(ref val6)).Normalize();
				Vector3 val7 = Vector3.Cross(val3, val6);
				float num2 = Mathf.Atan2(Vector3.Dot(val5, val7), Vector3.Dot(val5, val6)) * 57.29578f;
				float num3 = 0f;
				if (_angleValid)
				{
					num3 = num2 - _lastAngle;
					if (num3 > 180f)
					{
						num3 -= 360f;
					}
					else if (num3 < -180f)
					{
						num3 += 360f;
					}
				}
				_lastAngle = num2;
				_angleValid = true;
				num = Mathf.Abs(num3) / Mathf.Max(0.0001f, Time.fixedDeltaTime);
			}
			else
			{
				_angleValid = false;
			}
			float num4 = 0f;
			try
			{
				InputDevice deviceAtXRNode = InputDevices.GetDeviceAtXRNode((XRNode)(((Object)(object)instance.OffHand == (Object)(object)instance.LeftHand) ? 4 : 5));
				Vector3 val8 = default(Vector3);
				if (((InputDevice)(ref deviceAtXRNode)).isValid && ((InputDevice)(ref deviceAtXRNode)).TryGetFeatureValue(CommonUsages.deviceAngularVelocity, ref val8))
				{
					num4 = Mathf.Abs(Vector3.Dot(((Object)(object)instance.Root != (Object)null) ? instance.Root.TransformDirection(val8) : val8, ((Vector3)(ref val3)).normalized)) * 57.29578f;
				}
			}
			catch
			{
			}
			float num5 = Mathf.Max(num, num4);
			_angVel = Mathf.Lerp(_angVel, num5, 0.2f);
			bool flag = _angVel > 25f;
			if (flag)
			{
				if (__instance._isReelingOut)
				{
					FishingRodCast val9 = (FishingRodCast)(object)((__instance is FishingRodCast) ? __instance : null);
					if (val9 != null)
					{
						val9.StartReel();
					}
				}
				__instance._isReelingIn = true;
				if (_angVel > 380f)
				{
					__instance._curReelSpeedMulti = Mathf.Min(__instance._curReelSpeedMulti + __instance._reelMultiIncreaseSpeed * Time.fixedDeltaTime * (_angVel / 380f), 4f);
				}
			}
			else if (_wasCranking)
			{
				bool flag2 = false;
				try
				{
					flag2 = VRActions.Instance.RightTrigger.ReadValue<float>() >= 0.5f;
				}
				catch
				{
				}
				if (!flag2)
				{
					__instance._isReelingIn = false;
				}
			}
			_wasCranking = flag;
		}
	}
	[HarmonyPatch(typeof(PlayerPunching))]
	internal static class PunchPatches
	{
		internal struct CameraPoseState
		{
			internal Transform Camera;

			internal Vector3 Position;

			internal Quaternion Rotation;

			internal bool Changed;
		}

		internal static CameraPoseState BeginHeadAim(Transform camera)
		{
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: 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_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			CameraPoseState result = new CameraPoseState
			{
				Camera = camera
			};
			if (!Plugin.VREnabled || (Object)(object)camera == (Object)null)
			{
				return result;
			}
			try
			{
				Transform val = (((Object)(object)VRRig.Instance != (Object)null) ? VRRig.Instance.Head : null);
				if ((Object)(object)val == (Object)null)
				{
					return result;
				}
				result.Position = camera.position;
				result.Rotation = camera.rotation;
				result.Changed = true;
				camera.SetPositionAndRotation(val.position, val.rotation);
			}
			catch
			{
				result.Changed = false;
			}
			return result;
		}

		internal static void EndHeadAim(CameraPoseState state)
		{
			//IL_001f: 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)
			if (!state.Changed || (Object)(object)state.Camera == (Object)null)
			{
				return;
			}
			try
			{
				state.Camera.SetPositionAndRotation(state.Position, state.Rotation);
			}
			catch
			{
			}
		}

		private static bool IsLocalPlayerBody(Transform t)
		{
			if ((Object)(object)t == (Object)null)
			{
				return false;
			}
			try
			{
				Player playerFromBodyPart = PlayerManager.GetPlayerFromBodyPart(t);
				if ((Object)(object)playerFromBodyPart != (Object)null)
				{
					return (Object)(object)playerFromBodyPart == (Object)(object)Player.LocalPlayer;
				}
			}
			catch
			{
			}
			try
			{
				Player localPlayer = Player.LocalPlayer;
				if ((Object)(object)localPlayer != (Object)null && (Object)(object)localPlayer.Transform != (Object)null && (Object)(object)t.root != (Object)null && (Object)(object)t.root == (Object)(object)localPlayer.Transform.root)
				{
					return true;
				}
			}
			catch
			{
			}
			return false;
		}

		[HarmonyPostfix]
		[HarmonyPatch("CheckForPlayersAndLevel")]
		private static void ExcludeSelf(PlayerPunching __instance, ref Transform finalTarget, ref Vector3 finalHitPoint)
		{
			//IL_0015: 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 (Plugin.VREnabled && IsLocalPlayerBody(finalTarget))
			{
				finalTarget = null;
				finalHitPoint = Vector3.zero;
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch("HitTarget")]
		private static bool NoSelfHit(PlayerPunching __instance, int side)
		{
			if (!Plugin.VREnabled)
			{
				return true;
			}
			if (__instance._curTarget == null || side < 0 || side >= __instance._curTarget.Length)
			{
				return true;
			}
			if (IsLocalPlayerBody(__instance._curTarget[side]))
			{
				return false;
			}
			return true;
		}

		[HarmonyPrefix]
		[HarmonyPatch("FindPunchTarget")]
		private static void HeadAimPrefix(PlayerPunching __instance, out CameraPoseState __state)
		{
			Transform camera = null;
			try
			{
				camera = (((Object)(object)__instance._player != (Object)null) ? __instance._player.CamObject : null);
			}
			catch
			{
			}
			__state = BeginHeadAim(camera);
		}

		[HarmonyPostfix]
		[HarmonyPatch("FindPunchTarget")]
		private static void HeadAimPostfix(CameraPoseState __state)
		{
			EndHeadAim(__state);
		}
	}
	[HarmonyPatch(typeof(Melee))]
	internal static class KnuckleHeadAimPatches
	{
		[HarmonyPrefix]
		[HarmonyPatch("FindAttackTarget")]
		private static void HeadAimPrefix(Melee __instance, out PunchPatches.CameraPoseState __state)
		{
			__state = default(PunchPatches.CameraPoseState);
			try
			{
				if (Plugin.VREnabled && __instance._useBothHands)
				{
					__state = PunchPatches.BeginHeadAim(((Object)(object)((Item)__instance).Holder != (Object)null) ? ((Item)__instance).Holder.CamObject : null);
				}
			}
			catch
			{
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch("FindAttackTarget")]
		private static void HeadAimPostfix(PunchPatches.CameraPoseState __state)
		{
			PunchPatches.EndHeadAim(__state);
		}
	}
	[AttributeUsage(AttributeTargets.Class)]
	internal sealed class NetOnlyPatchAttribute : Attribute
	{
	}
	[HarmonyPatch(typeof(OtherPlayer))]
	[NetOnlyPatch]
	internal static class RemoteOtherPlayerPatches
	{
		[HarmonyPrefix]
		[HarmonyPatch("ApplyReceivedPosRot")]
		private static bool ApplyReceivedPosRotPrefix(OtherPlayer __instance)
		{
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_013f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0159: Unknown result type (might be due to invalid IL or missing references)
			//IL_015f: Unknown result type (might be due to invalid IL or missing references)
			if (!VRConfig.MultiplayerVRSync.Value)
			{
				return true;
			}
			try
			{
				Player player = __instance._player;
				if ((Object)(object)player == (Object)null)
				{
					return true;
				}
				if (((NetworkBehaviour)player).Owner == (NetworkConnection)null || ((NetworkBehaviour)player).Owner.IsLocalClient)
				{
					return true;
				}
				if ((Object)(object)player == (Object)(object)Player.LocalPlayer)
				{
					return true;
				}
				if ((Object)(object)player.Dying != (Object)null && player.Dying.IsDead)
				{
					return true;
				}
				if (((Object)(object)player.Other != (Object)null && player.Other.OnBoat) || ((Object)(object)player.Movement != (Object)null && player.Movement.OnBoat))
				{
					return true;
				}
				if ((Object)(object)((NetworkBehaviour)player).NetworkObject == (Object)null)
				{
					return true;
				}
				if (!VRNetSync.TryGetInterpolatedPose(((NetworkBehaviour)player).NetworkObject.ObjectId, out var pose))
				{
					return true;
				}
				__instance._transform.position = pose.BodyPos;
				__instance._transform.rotation = Quaternion.Euler(0f, pose.BodyYaw, 0f);
				float num = 1f - Mathf.Exp(-25f * Time.deltaTime);
				__instance._camProxy.localRotation = Quaternion.Slerp(__instance._camProxy.localRotation, Quaternion.Euler(__instance._receivedRot.x, 0f, 0f), num);
				return false;
			}
			catch
			{
				return true;
			}
		}
	}
	[HarmonyPatch(typeof(PlayerHands))]
	[NetOnlyPatch]
	internal static class RemoteHandsPatches
	{
		[HarmonyPrefix]
		[HarmonyPatch("LateUpdate")]
		private static bool SkipGameHands(PlayerHands __instance)
		{
			return !IsDrivenRemote(__instance);
		}

		[HarmonyPostfix]
		[HarmonyPatch("LateUpdate")]
		private static void DriveHands(PlayerHands __instance)
		{
			//IL_0077: 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_007e: 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_008a: 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_008d: 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_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_00b3: 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_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_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: 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_00cc: Unknown result type (might be due to invalid IL or missing references)
			if (!IsDrivenRemote(__instance))
			{
				return;
			}
			try
			{
				Player player = __instance._player;
				if (!((Object)(object)player == (Object)null) && !((Object)(object)((NetworkBehaviour)player).NetworkObject == (Object)null) && !((Object)(object)__instance.HandBoneRight == (Object)null) && !((Object)(object)__instance.HandBoneLeft == (Object)null) && VRNetSync.TryGetInterpolatedPose(((NetworkBehaviour)player).NetworkObject.ObjectId, out var pose))
				{
					Quaternion val = Quaternion.Euler(0f, pose.BodyYaw, 0f);
					Vector3 bodyPos = pose.BodyPos;
					__instance.HandBoneRight.SetPositionAndRotation(bodyPos + val * pose.RightPos, val * pose.RightRot);
					__instance.HandBoneLeft.SetPositionAndRotation(bodyPos + val * pose.LeftPos, val * pose.LeftRot);
					if ((Object)(object)player.Arms != (Object)null)
					{
						player.Arms.SetIKTarget(__instance.HandBoneRight, __instance.HandBoneLeft);
					}
				}
			}
			catch
			{
			}
		}

		private static bool IsDrivenRemote(PlayerHands hands)
		{
			if (!VRConfig.MultiplayerVRSync.Value)
			{
				return false;
			}
			try
			{
				Player player = hands._player;
				if ((Object)(object)player == (Object)null || ((NetworkBehaviour)player).Owner == (NetworkConnection)null || ((NetworkBehaviour)player).Owner.IsLocalClient)
				{
					return false;
				}
				if ((Object)(object)player == (Object)(object)Player.LocalPlayer)
				{
					return false;
				}
				if ((Object)(object)player.Dying != (Object)null && player.Dying.IsDead)
				{
					return false;
				}
				if (((Object)(object)player.Other != (Object)null && player.Other.OnBoat) || ((Object)(object)player.Movement != (Object)null && player.Movement.OnBoat))
				{
					return false;
				}
				if ((Object)(object)((NetworkBehaviour)player).NetworkObject == (Object)null)
				{
					return false;
				}
				VRPoseBroadcast pose;
				return VRNetSync.TryGetPose(((NetworkBehaviour)player).NetworkObject.ObjectId, out pose);
			}
			catch
			{
				return false;
			}
		}
	}
	[HarmonyPatch(typeof(PlayerLegs))]
	[NetOnlyPatch]
	internal static class RemoteLegsPatches
	{
		[HarmonyPostfix]
		[HarmonyPatch("Update")]
		private static void LegsPostfix(PlayerLegs __instance)
		{
			//IL_0199: Unknown result type (might be due to invalid IL or missing references)
			//IL_019e: 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_01bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b4: 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_01d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e4: 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_01e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f4: 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_01f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f9: 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_0211: 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_0214: Unknown result type (might be due to invalid IL or missing references)
			//IL_0216: 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_022e: Unknown result type (might be due to invalid IL or missing references)
			//IL_022f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0231: Unknown result type (might be due to invalid IL or missing references)
			if (!VRConfig.MultiplayerVRSync.Value)
			{
				return;
			}
			try
			{
				Player player = __instance._player;
				if ((Object)(object)player == (Object)null || ((NetworkBehaviour)player).Owner == (NetworkConnection)null || ((NetworkBehaviour)player).Owner.IsLocalClient || (Object)(object)player == (Object)(object)Player.LocalPlayer || ((Object)(object)player.Dying != (Object)null && player.Dying.IsDead) || ((Object)(object)player.Other != (Object)null && player.Other.OnBoat) || ((Object)(object)player.Movement != (Object)null && player.Movement.OnBoat) || (Object)(object)((NetworkBehaviour)player).NetworkObject == (Object)null || !VRNetSync.TryGetInterpolatedPose(((NetworkBehaviour)player).NetworkObject.ObjectId, out var pose) || !pose.HasBody)
				{
					return;
				}
				if (__instance._legTargets != null && __instance._legTargets.Length >= 2 && __instance._ikPoles != null && __instance._ikPoles.Length >= 2 && __instance._footModels != null && __instance._footModels.Length >= 2 && !((Object)(object)__instance._legTargets[0] == (Object)null) && !((Object)(object)__instance._legTargets[1] == (Object)null) && !((Object)(object)__instance._ikPoles[0] == (Object)null) && !((Object)(object)__instance._ikPoles[1] == (Object)null) && !((Object)(object)__instance._footModels[0] == (Object)null) && !((Object)(object)__instance._footModels[1] == (Object)null))
				{
					Quaternion val = Quaternion.Euler(0f, pose.BodyYaw, 0f);
					Vector3 bodyPos = pose.BodyPos;
					for (int i = 0; i < 2; i++)
					{
						Vector3 val2 = ((i == 0) ? pose.FootLPos : pose.FootRPos);
						Quaternion val3 = ((i == 0) ? pose.FootLRot : pose.FootRRot);
						Vector3 val4 = ((i == 0) ? pose.FootLPole : pose.FootRPole);
						__instance._legTargets[i].position = bodyPos + val * val2;
						__instance._ikPoles[i].position = bodyPos + val * val4;
						__instance._footModels[i].rotation = val * val3;
					}
				}
			}
			catch
			{
			}
		}
	}
	[HarmonyPatch(typeof(PlayerDeathCam))]
	[NetOnlyPatch]
	internal static class DeathCamCarryPatches
	{
		private static Vector3 _carryAnchor;

		private static bool _carryAnchorInit;

		[HarmonyPostfix]
		[HarmonyPatch("OrbitCamera")]
		private static void SmoothCarriedAnchor(PlayerDeathCam __instance)
		{
			//IL_0099: 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_00cc: 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_00d5: 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_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: 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)
			//IL_00f1: 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_00fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: 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_00a9: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				Player player = __instance._player;
				if ((Object)(object)player == (Object)null || !((NetworkBehaviour)player).Owner.IsLocalClient)
				{
					return;
				}
				PlayerDying dying = player.Dying;
				if ((Object)(object)dying == (Object)null || !dying.IsDead || (Object)(object)dying.DeadPlayer == (Object)null)
				{
					_carryAnchorInit = false;
					return;
				}
				DeadPlayer deadPlayer = dying.DeadPlayer;
				if ((Object)(object)((Item)deadPlayer).SyncedHolder == (Object)null || (Object)(object)((Item)deadPlayer).SyncedHolder == (Object)(object)player)
				{
					_carryAnchorInit = false;
					return;
				}
				Camera deathCam = __instance._deathCam;
				if (!((Object)(object)deathCam == (Object)null))
				{
					Vector3 position = ((Component)deadPlayer).transform.position;
					if (!_carryAnchorInit)
					{
						_carryAnchor = position;
						_carryAnchorInit = true;
					}
					float num = 1f - Mathf.Exp(-10f * Time.deltaTime);
					_carryAnchor = Vector3.Lerp(_carryAnchor, position, num);
					Vector3 val = ((Component)deathCam).transform.position - position;
					((Component)deathCam).transform.position = _carryAnchor + val;
				}
			}
			catch
			{
			}
		}
	}
	[HarmonyPatch]
	internal static class ScreenUIPatches
	{
		private static Transform _caughtHolder;

		private const float ProjectionPlaneDistance = 2f;

		private const float DotWorldScale = 3f;

		private static void RemapScreenPx(Transform t)
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Invalid comparison between Unknown and I4
			//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_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: 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_007b: 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_009e: 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_00c2: 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_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)t == (Object)null)
			{
				return;
			}
			Canvas componentInParent = ((Component)t).GetComponentInParent<Canvas>(true);
			if (!((Object)(object)componentInParent == (Object)null) && (int)componentInParent.renderMode == 2)
			{
				Transform transform = ((Component)componentInParent).transform;
				RectTransform component = ((Component)componentInParent).GetComponent<RectTransform>();
				if (!((Object)(object)component == (Object)null))
				{
					Vector3 position = t.position;
					Rect rect = component.rect;
					float num = Mathf.Max(1f, ((Rect)(ref rect)).width);
					rect = component.rect;
					float num2 = Mathf.Max(1f, ((Rect)(ref rect)).height);
					float num3 = ((component.sizeDelta.x > 1f) ? component.sizeDelta.x : num);
					float num4 = ((component.sizeDelta.y > 1f) ? component.sizeDelta.y : num2);
					Vector3 val = default(Vector3);
					((Vector3)(ref val))..ctor((position.x / num - 0.5f) * num3, (position.y / num2 - 0.5f) * num4, 0f);
					t.position = transform.TransformPoint(val);
				}
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(FishingUI), "LateUpdate")]
		private static void FishingCaughtText(FishingUI __instance)
		{
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			if (!Plugin.VREnabled)
			{
				return;
			}
			try
			{
				if ((Object)(object)_caughtHolder == (Object)null)
				{
					return;
				}
				TextMeshProUGUI caughtFishText = __instance._caughtFishText;
				if (!((Object)(object)caughtFishText == (Object)null))
				{
					((TMP_Text)caughtFishText).transform.position = _caughtHolder.position;
					_caughtHolder.localRotation = Quaternion.identity;
					if ((Object)(object)((TMP_Text)caughtFishText).transform.parent == (Object)(object)_caughtHolder)
					{
						((TMP_Text)caughtFishText).transform.localRotation = Quaternion.identity;
					}
				}
			}
			catch
			{
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(FishingUI), "CaughtFishUI")]
		private static void FishingCaughtHolder(FishingUI __instance)
		{
			//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_00d2: Unknown result type (might be due to invalid IL or missing references)
			if (!Plugin.VREnabled)
			{
				return;
			}
			try
			{
				GameObject caughtFishHolder = __instance._caughtFishHolder;
				TextMeshProUGUI caughtFishText = __instance._caughtFishText;
				if ((Object)(object)caughtFishHolder == (Object)null || (Object)(object)caughtFishText == (Object)null)
				{
					return;
				}
				Canvas caughtFishPanel = VRUIManager.GetCaughtFishPanel(GameInfo.CurCamera);
				if ((Object)(object)caughtFishPanel == (Object)null)
				{
					return;
				}
				Transform transform = caughtFishHolder.transform;
				if ((Object)(object)transform.parent != (Object)(object)((Component)caughtFishPanel).transform)
				{
					transform.SetParent(((Component)caughtFishPanel).transform, true);
					if ((Object)(object)((TMP_Text)caughtFishText).transform.parent != (Object)(object)transform)
					{
						((TMP_Text)caughtFishText).transform.SetParent(transform, true);
					}
					_caughtHolder = transform;
				}
				transform.localPosition = new Vector3(0f, 150f, 0f);
				transform.localRotation = Quaternion.identity;
				if ((Object)(object)((TMP_Text)caughtFishText).transform.parent == (Object)(object)transform)
				{
					((TMP_Text)caughtFishText).transform.localRotation = Quaternion.identity;
				}
			}
			catch
			{
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(ItemUI), "LateUpdate")]
		private static void WorldAnchorPriceTag(ItemUI __instance)
		{
			//IL_00e6: 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)
			//IL_00f1: 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_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: 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_011b: 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_0125: Unknown result type (might be due to invalid IL or missing references)
			//IL_0148: Unknown result type (might be due to invalid IL or missing references)
			//IL_0153: Unknown result type (might be due to invalid IL or missing references)
			//IL_0158: Unknown result type (might be due to invalid IL or missing references)
			//IL_013a: Unknown result type (might be due to invalid IL or missing references)
			//IL_013f: Unknown result type (might be due to invalid IL or missing references)
			if (!Plugin.VREnabled)
			{
				return;
			}
			try
			{
				TextMeshProUGUI lookingAtText = __instance._lookingAtText;
				if ((Object)(object)lookingAtText == (Object)null || (Object)(object)__instance._lookAtTarget == (Object)null || !__instance._isShowingLookAtText)
				{
					return;
				}
				Canvas priceAnchor = VRUIManager.GetPriceAnchor(GameInfo.CurCamera);
				if ((Object)(object)priceAnchor == (Object)null)
				{
					return;
				}
				if ((Object)(object)((TMP_Text)lookingAtText).transform.parent != (Object)(object)((Component)priceAnchor).transform)
				{
					((Transform)((TMP_Text)lookingAtText).rectTransform).SetParent(((Component)priceAnchor).transform, false);
					((TMP_Text)lookingAtText).rectTransform.anchorMin = new Vector2(0.5f, 0.5f);
					((TMP_Text)lookingAtText).rectTransform.anchorMax = new Vector2(0.5f, 0.5f);
					((TMP_Text)lookingAtText).rectTransform.pivot = new Vector2(0.5f, 0.5f);
					((Transform)((TMP_Text)lookingAtText).rectTransform).localPosition = Vector3.zero;
				}
				((TMP_Text)lookingAtText).transform.position = __instance._lookAtTarget.position + __instance._textOffset;
				Camera curCamera = GameInfo.CurCamera;
				if ((Object)(object)curCamera != (Object)null)
				{
					Vector3 val = ((TMP_Text)lookingAtText).transform.position - ((Component)curCamera).transform.position;
					if (((Vector3)(ref val)).sqrMagnitude < 1E-06f)
					{
						val = ((Component)curCamera).transform.forward;
					}
					((TMP_Text)lookingAtText).transform.rotation = Quaternion.LookRotation(((Vector3)(ref val)).normalized, ((Component)curCamera).transform.up);
				}
			}
			catch
			{
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(NpcUI), "LateUpdate")]
		private static void NpcBackground(NpcUI __instance)
		{
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: 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_0125: Unknown result type (might be due to invalid IL or missing references)
			//IL_0131: Unknown result type (might be due to invalid IL or missing references)
			//IL_0136: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: 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_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_0175: Unknown result type (might be due to invalid IL or missing references)
			if (!Plugin.VREnabled)
			{
				return;
			}
			try
			{
				Image npcBackground = __instance._npcBackground;
				if ((Object)(object)npcBackground == (Object)null)
				{
					return;
				}
				Canvas priceAnchor = VRUIManager.GetPriceAnchor(GameInfo.CurCamera);
				if ((Object)(object)priceAnchor == (Object)null)
				{
					return;
				}
				Transform transform = ((Component)npcBackground).transform;
				if ((Object)(object)transform.parent != (Object)(object)((Component)priceAnchor).transform)
				{
					transform.SetParent(((Component)priceAnchor).transform, false);
				}
				float num = 0f;
				try
				{
					num = (((Object)(object)__instance._npcCanvas != (Object)null) ? __instance._npcCanvas.alpha : 0f);
				}
				catch
				{
				}
				CanvasGroup val = ((Component)npcBackground).GetComponent<CanvasGroup>();
				if ((Object)(object)val == (Object)null)
				{
					val = ((Component)npcBackground).gameObject.AddComponent<CanvasGroup>();
				}
				val.alpha = num;
				if (!NpcUI.NPCDialougeOpen || (Object)(object)__instance._npcTarget == (Object)null)
				{
					return;
				}
				Vector3 val2 = (transform.position = __instance._npcTarget.position);
				Camera curCamera = GameInfo.CurCamera;
				if ((Object)(object)curCamera != (Object)null)
				{
					Vector3 val3 = val2 - ((Component)curCamera).transform.position;
					if (((Vector3)(ref val3)).sqrMagnitude < 1E-06f)
					{
						val3 = ((Component)curCamera).transform.forward;
					}
					transform.rotation = Quaternion.LookRotation(((Vector3)(ref val3)).normalized, ((Component)curCamera).transform.up);
				}
				try
				{
					TextMeshProUGUI npcText = __instance._npcText;
					if ((Object)(object)npcText != (Object)null && !((TMP_Text)npcText).transform.IsChildOf(transform))
					{
						Color color = ((Graphic)npcText).color;
						color.a = num;
						((Graphic)npcText).color = color;
					}
				}
				catch
				{
				}
			}
			catch
			{
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(OnHitUI), "LateUpdate")]
		private static void HitMarkersAndDamage(OnHitUI __instance)
		{
			//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_00d7: 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_00e6: Unknown result type (might be due to invalid IL or missing references)
			if (!Plugin.VREnabled)
			{
				return;
			}
			try
			{
				Canvas priceAnchor = VRUIManager.GetPriceAnchor(GameInfo.CurCamera);
				if ((Object)(object)priceAnchor == (Object)null)
				{
					return;
				}
				Camera curCamera = GameInfo.CurCamera;
				List<Image> hitMarkers = __instance._hitMarkers;
				List<Vector3> hitMarkerPositions = __instance._hitMarkerPositions;
				if (hitMarkers != null && hitMarkerPositions != null)
				{
					for (int i = 0; i < hitMarkers.Count && i < hitMarkerPositions.Count; i++)
					{
						WorldAnchorHit(((Object)(object)hitMarkers[i] != (Object)null) ? ((Component)hitMarkers[i]).transform : null, hitMarkerPositions[i], Vector3.zero, ((Component)priceAnchor).transform, curCamera);
					}
				}
				List<TextMeshProUGUI> damageTexts = __instance._damageTexts;
				List<Vector3> damageTextPositions = __instance._damageTextPositions;
				if (damageTexts != null && damageTextPositions != null)
				{
					for (int j = 0; j < damageTexts.Count && j < damageTextPositions.Count; j++)
					{
						WorldAnchorHit(((Object)(object)damageTexts[j] != (Object)null) ? ((TMP_Text)damageTexts[j]).transform : null, damageTextPositions[j], Vector3.up * 0.18f, ((Component)priceAnchor).transform, curCamera);
					}
				}
			}
			catch
			{
			}
		}

		private static void WorldAnchorHit(Transform t, Vector3 worldPos, Vector3 worldUpOffset, Transform anchor, Camera cam)
		{
			//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_002c: 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_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_0064: 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_0075: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)t == (Object)null || (Object)(object)anchor == (Object)null)
			{
				return;
			}
			if ((Object)(object)t.parent != (Object)(object)anchor)
			{
				t.SetParent(anchor, false);
			}
			t.position = worldPos + worldUpOffset;
			if ((Object)(object)cam != (Object)null)
			{
				Vector3 val = worldPos - ((Component)cam).transform.position;
				if (((Vector3)(ref val)).sqrMagnitude > 1E-06f)
				{
					t.rotation = Quaternion.LookRotation(((Vector3)(ref val)).normalized, ((Component)cam).transform.up);
				}
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(SwapOutfitButtons), "Update")]
		private static void OutfitButtons(SwapOutfitButtons __instance)
		{
			if (!Plugin.VREnabled)
			{
				return;
			}
			try
			{
				PinCustomizationButtons(__instance, MainMenuManager.MenuCam);
			}
			catch
			{
			}
		}

		public static void RePinCustomizationButtons()
		{
			if (!Plugin.VREnabled || !LocalSkin.IsInSkinCustomization)
			{
				return;
			}
			try
			{
				Camera menuCam = MainMenuManager.MenuCam;
				if (!((Object)(object)menuCam == (Object)null))
				{
					SwapOutfitButtons[] array = Object.FindObjectsOfType<SwapOutfitButtons>(true);
					for (int i = 0; i < array.Length; i++)
					{
						PinCustomizationButtons(array[i], menuCam);
					}
				}
			}
			catch
			{
			}
		}

		private static void PinCustomizationButtons(SwapOutfitButtons buttons, Camera cam)
		{
			if (!((Object)(object)buttons == (Object)null) && !((Object)(object)cam == (Object)null) && LocalSkin.IsInSkinCustomization)
			{
				PlaceCustomizationTarget(buttons._hatRect, LocalSkin.HatTarget, cam);
				PlaceCustomizationTarget(buttons._accessoryRect, LocalSkin.AccessoryTarget, cam);
				PlaceCustomizationTarget(buttons._outfitRect, LocalSkin.OutfitTarget, cam);
			}
		}

		private static void PlaceCustomizationTarget(RectTransform rect, Transform target, Camera cam)
		{
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Invalid comparison between Unknown and I4
			//IL_0051: 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_007b: 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_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)rect == (Object)null || (Object)(object)target == (Object)null || (Object)(object)cam == (Object)null)
			{
				return;
			}
			Canvas componentInParent = ((Component)rect).GetComponentInParent<Canvas>(true);
			if ((Object)(object)componentInParent == (Object)null)
			{
				return;
			}
			componentInParent = (((Object)(object)componentInParent.rootCanvas != (Object)null) ? componentInParent.rootCanvas : componentInParent);
			if ((int)componentInParent.renderMode != 2)
			{
				return;
			}
			Vector3 val = target.position - ((Component)cam).transform.position;
			if (!(((Vector3)(ref val)).sqrMagnitude < 1E-06f) && !(Vector3.Dot(((Component)cam).transform.forward, val) <= 0f))
			{
				Plane val2 = default(Plane);
				((Plane)(ref val2))..ctor(((Component)componentInParent).transform.forward, ((Component)componentInParent).transform.position);
				Ray val3 = default(Ray);
				((Ray)(ref val3))..ctor(((Component)cam).transform.position, ((Vector3)(ref val)).normalized);
				float num = default(float);
				if (((Plane)(ref val2)).Raycast(val3, ref num) && !(num <= 0f))
				{
					((Transform)rect).position = ((Ray)(ref val3)).GetPoint(num);
					((Transform)rect).rotation = ((Component)componentInParent).transform.rotation;
				}
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(CloseItemsUI), "LateUpdate")]
		private static void WorldAnchorDots(CloseItemsUI __instance)
		{
			if (!Plugin.VREnabled)
			{
				return;
			}
			try
			{
				PinDots(__instance, GameInfo.CurCamera);
			}
			catch
			{
			}
		}

		public static void RePinWorldDots()
		{
			if (!Plugin.VREnabled)
			{
				return;
			}
			try
			{
				CloseItemsUI[] array = Object.FindObjectsOfType<CloseItemsUI>(true);
				for (int i = 0; i < array.Length; i++)
				{
					PinDots(array[i], GameInfo.CurCamera);
				}
			}
			catch
			{
			}
		}

		private static void PinDots(CloseItemsUI ui, Camera cam)
		{
			//IL_0092: 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_00b3: 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_01d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: 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_013a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0166: Unknown result type (might be due to invalid IL or missing references)
			//IL_017c: Unknown result type (might be due to invalid IL or missing references)
			//IL_018c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0199: 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)
			//IL_012b: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)ui == (Object)null || (Object)(object)cam == (Object)null || ui._closeItemsDots == null || ui._closestItems == null)
			{
				return;
			}
			bool flag = CloseItemsUI._dotsEnabled && Object.op_Implicit((Object)(object)Player.LocalPlayer) && !EndGameEffects.IsShowingEndGame;
			int num = Mathf.Min(ui._closeItemsDots.Count, ui._closestItems.Length);
			for (int i = 0; i < num; i++)
			{
				Image val = ui._closeItemsDots[i];
				Item val2 = ui._closestItems[i];
				if ((Object)(object)val == (Object)null)
				{
					continue;
				}
				if (!flag || ShouldHideDotItem(val2))
				{
					((Graphic)val).color = Color.clear;
					continue;
				}
				Vector3 val3 = ((Component)val2).transform.position - ((Component)cam).transform.position;
				if (((Vector3)(ref val3)).sqrMagnitude < 1E-06f || Vector3.Dot(((Component)cam).transform.forward, val3) <= 0f)
				{
					((Graphic)val).color = Color.clear;
					continue;
				}
				bool flag2 = Object.op_Implicit((Object)(object)val2.Creature) && !val2.Creature.IsDead;
				((Graphic)val).color = (flag2 ? ui._aliveColor : (Object.op_Implicit((Object)(object)val2.DeadPlayer) ? GameInfo.OrangeColor : Color.white));
				EnsureDotAlwaysVisible((Graphic)(object)val);
				float num2 = ((Vector3)(ref val3)).magnitude / 2f;
				((Component)val).transform.position = ((Component)val2).transform.position;
				((Component)val).transform.rotation = ((Component)cam).transform.rotation;
				((Component)val).transform.localScale = Vector3.one * (3f * num2);
			}
			for (int j = num; j < ui._closeItemsDots.Count; j++)
			{
				if ((Object)(object)ui._closeItemsDots[j] != (Object)null)
				{
					((Graphic)ui._closeItemsDots[j]).color = Color.clear;
				}
			}
		}

		private static bool ShouldHideDotItem(Item item)
		{
			if (!Object.op_Implicit((Object)(object)item) || Object.op_Implicit((Object)(object)item.Holder) || ((NetworkBehaviour)item).IsDeinitializing)
			{
				return true;
			}
			if (Object.op_Implicit((Object)(object)item.Bird) && !((Creature)item.Bird).IsDead)
			{
				return true;
			}
			return item.IgnoredByCloseDots;
		}

		private static void EnsureDotAlwaysVisible(Graphic dot)
		{
			//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_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Expected O, but got Unknown
			if ((Object)(object)dot == (Object)null)
			{
				return;
			}
			try
			{
				Material val = (((Object)(object)dot.material != (Object)null) ? dot.material : Canvas.GetDefaultCanvasMaterial());
				if (!((Object)(object)val == (Object)null) && !(((Object)val).name ?? "").EndsWith(" [VR Always Visible]", StringComparison.Ordinal))
				{
					Material val2 = new Material(val)
					{
						name = (((Object)val).name ?? "ItemDot") + " [VR Always Visible]",
						hideFlags = (HideFlags)61
					};
					val2.SetInt("unity_GUIZTestMode", 8);
					if (val2.HasProperty("_ZTest"))
					{
						val2.SetInt("_ZTest", 8);
					}
					dot.material = val2;
				}
			}
			catch
			{
			}
		}
	}
	[HarmonyPatch(typeof(PlayerUI))]
	internal static class SniperUIPatches
	{
		[HarmonyPrefix]
		[HarmonyPatch("ToggleSniperUI")]
		private static bool NoSniperOverlay(bool to)
		{
			return !Plugin.VREnabled;
		}

		[HarmonyPrefix]
		[HarmonyPatch("SetSniperUI")]
		private static bool NoSniperOverlayUpdate(Vector3 position, float posWeight, float scale)
		{
			return !Plugin.VREnabled;
		}
	}
	[HarmonyPatch(typeof(Attachments))]
	internal static class SightModelPatches
	{
		[HarmonyPrefix]
		[HarmonyPatch("ToggleSightModels")]
		private static void KeepSightsVisible(ref bool to)
		{
			if (Plugin.VREnabled)
			{
				to = true;
			}
		}
	}
	[HarmonyPatch(typeof(PlayerCamera))]
	internal static class SniperFovPatches
	{
		[HarmonyPrefix]
		[HarmonyPatch("SetFov")]
		private static bool NoSniperZoom(PlayerCamera __instance)
		{
			if (!Plugin.VREnabled)
			{
				return true;
			}
			try
			{
				Player player = __instance._player;
				if ((Object)(object)player == (Object)null)
				{
					return true;
				}
				Item val = (((Object)(object)player.Holding != (Object)null) ? player.Holding.HeldItem : null);
				if ((Object)(object)val == (Object)null || (Object)(object)val.Weapon == (Object)null)
				{
					return true;
				}
				Weapon weapon = val.Weapon;
				if (!weapon.IsAds)
				{
					return true;
				}
				if (!weapon._attachments.UseSniperUi)
				{
					return true;
				}
				return false;
			}
			catch
			{
				return true;
			}
		}
	}
	[HarmonyPatch(typeof(Weapon), "Shoot")]
	internal static class SniperProjectileAimPatches
	{
		[HarmonyPrefix]
		private static void UsePhysicalMuzzle(Weapon __instance, out float __state)
		{
			__state = -1f;
			if (!Plugin.HeadsetActive)
			{
				return;
			}
			try
			{
				if (!((Object)(object)__instance == (Object)null) && !((Object)(object)((Item)__instance).Holder == (Object)null) && !(((NetworkBehaviour)((Item)__instance).Holder).Owner == (NetworkConnection)null) && ((NetworkBehaviour)((Item)__instance).Holder).Owner.IsLocalClient && !((Object)(object)__instance.Attachments == (Object)null) && __instance.Attachments.UseSniperUi && !(__instance._aimPercent <= 0.9f))
				{
					__state = __instance._aimPercent;
					__instance._aimPercent = 0.9f;
				}
			}
			catch
			{
				__state = -1f;
			}
		}

		[HarmonyPostfix]
		private static void RestoreAimPercent(Weapon __instance, float __state)
		{
			if (__state >= 0f && (Object)(object)__instance != (Object)null)
			{
				__instance._aimPercent = __state;
			}
		}
	}
	[HarmonyPatch(typeof(WaterManager))]
	internal static class WaterUnderwaterPatches
	{
		private static readonly MethodInfo _toggle = AccessTools.Method(typeof(WaterManager), "TogglePlayerUnderwater", new Type[2]
		{
			typeof(bool),
			typeof(bool)
		}, (Type[])null);

		private static void Toggle(WaterManager wm, bool under)
		{
			try
			{
				_toggle?.Invoke(wm, new object[2] { under, false });
			}
			catch
			{
			}
		}

		internal static void UpdateFromRenderedVRView()
		{
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			if (!Plugin.VREnabled)
			{
				return;
			}
			try
			{
				WaterManager instance = WaterManager._instance;
				Player localPlayer = Player.LocalPlayer;
				if (!((Object)(object)instance == (Object)null) && !((Object)(object)localPlayer == (Object)null))
				{
					Transform val = (((Object)(object)localPlayer.Camera != (Object)null && (Object)(object)localPlayer.Camera.Cam != (Object)null) ? ((Component)localPlayer.Camera.Cam).transform : (((Object)(object)localPlayer.CurCam != (Object)null) ? ((Component)localPlayer.CurCam).transform : null));
					if (!((Object)(object)val == (Object)null))
					{
						bool under = val.position.y < WaterManager.GetWaterHeight(val.position) + 0.1f;
						Toggle(instance, under);
					}
				}
			}
			catch
			{
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch("CheckPlayerUnderwater")]
		private static bool CheckUnderwaterVR(WaterManager __instance)
		{
			//IL_0092: 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)
			if (!Plugin.VREnabled || _toggle == null)
			{
				return true;
			}
			try
			{
				Player localPlayer = Player.LocalPlayer;
				if ((Object)(object)localPlayer == (Object)null)
				{
					Toggle(__instance, under: false);
					return false;
				}
				Transform val = (((Object)(object)localPlayer.Camera != (Object)null && (Object)(object)localPlayer.Camera.Cam != (Object)null) ? ((Component)localPlayer.Camera.Cam).transform : (((Object)(object)localPlayer.CurCam != (Object)null) ? ((Component)localPlayer.CurCam).transform : null));
				if ((Object)(object)val == (Object)null)
				{
					return true;
				}
				bool under = val.position.y < WaterManager.GetWaterHeight(val.position) + 0.1f;
				Toggle(__instance, under);
				return false;
			}
			catch
			{
				return true;
			}
		}
	}
}
namespace HowToFishVR.Net
{
	public class VRNetSync : MonoBehaviour
	{
		private struct Snap
		{
			public float T;

			public VRPoseBroadcast P;
		}

		private readonly HashSet<NetworkConnection> _modded = new HashSet<NetworkConnection>();

		private static readonly Dictionary<int, VRPoseBroadcast> _latest = new Dictionary<int, VRPoseBroadcast>();

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

		private static readonly Dictionary<int, List<Snap>> _buffers = new Dictionary<int, List<Snap>>();

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

		private bool _clientRegistered;

		private bool _serverRegistered;

		private bool _relayActive;

		private float _helloTimer;

		private float _poseTimer;

		private int _myObjectId = -1;

		private const float POSE_STALE = 1.5f;

		public static VRNetSync Instance { get; private set; }

		public static VRNetSync Create()
		{
			//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_0010: Expected O, but got Unknown
			GameObject val = new GameObject("HowToFishVR NetSync");
			Object.DontDestroyOnLoad((Object)val);
			return val.AddComponent<VRNetSync>();
		}

		private void Awake()
		{
			Instance = this;
			VRBroadcastSerializers.Register();
		}

		public static bool TryGetPose(int objectId, out VRPoseBroadcast pose)
		{
			pose = default(VRPoseBroadcast);
			if (!_latest.TryGetValue(objectId, out pose))
			{
				return false;
			}
			if (_lastSeen.TryGetValue(objectId, out var value) && Time.unscaledTime - value > 1.5f)
			{
				return false;
			}
			return true;
		}

		private static void AddSample(int id, VRPoseBroadcast p)
		{
			float unscaledTime = Time.unscaledTime;
			if (!_buffers.TryGetValue(id, out var value))
			{
				value = new List<Snap>(8);
				_buffers[id] = value;
			}
			if (value.Count > 0)
			{
				float num = unscaledTime - value[value.Count - 1].T;
				if (num > 0.0005f && num < 1f)
				{
					_avgInterval.TryGetValue(id, out var value2);
					_avgInterval[id] = ((value2 > 0f) ? Mathf.Lerp(value2, num, 0.2f) : num);
				}
			}
			value.Add(new Snap
			{
				T = unscaledTime,
				P = p
			});
			float num2 = unscaledTime - 0.6f;
			int i;
			for (i = 0; i < value.Count - 2 && value[i].T < num2; i++)
			{
			}
			if (i > 0)
			{
				value.RemoveRange(0, i);
			}
		}

		public static bool TryGetInterpolatedPose(int objectId, out VRPoseBroadcast pose)
		{
			pose = default(VRPoseBroadcast);
			if (!_buffers.TryGetValue(objectId, out var value) || value.Count == 0)
			{
				return false;
			}
			float unscaledTime = Time.unscaledTime;
			if (unscaledTime - value[value.Count - 1].T > 1.5f)
			{
				return false;
			}
			float value2;
			float num = Mathf.Clamp(((_avgInterval.TryGetValue(objectId, out value2) && value2 > 0f) ? value2 : 0.0625f) * 1.4f, 0.04f, 0.14f);
			float num2 = unscaledTime - num;
			if (value.Count == 1 || num2 <= value[0].T)
			{
				pose = value[0].P;
				return true;
			}
			for (int num3 = value.Count - 1; num3 >= 1; num3--)
			{
				if (value[num3 - 1].T <= num2 && num2 <= value[num3].T)
				{
					float num4 = value[num3].T - value[num3 - 1].T;
					float t = ((num4 > 1E-05f) ? ((num2 - value[num3 - 1].T) / num4) : 1f);
					pose = LerpPose(value[num3 - 1].P, value[num3].P, t);
					return true;
				}
			}
			Snap snap = value[value.Count - 2];
			Snap snap2 = value[value.Count - 1];
			float num5 = snap2.T - snap.T;
			float num6 = ((num5 > 1E-05f) ? Mathf.Min((num2 - snap2.T) / num5, 1f) : 0f);
			pose = LerpPose(snap.P, snap2.P, 1f + num6);
			return true;
		}

		private static VRPoseBroadcast LerpPose(VRPoseBroadcast a, VRPoseBroadcast b, float t)
		{
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: 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_005f: 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_006b: 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_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: 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_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: 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_00bb: 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_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: 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_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: 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)
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: 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_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: 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_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_0127: Unknown result type (might be due to invalid IL or missing references)
			//IL_012d: 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_0140: Unknown result type (might be due to invalid IL or missing references)
			//IL_0146: 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_0151: 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_0179: Unknown result type (might be due to invalid IL or missing references)
			//IL_017f: 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_018c: 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_0198: 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_01b2: 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_01be: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d7: 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_01f1: 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_01fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0203: Unknown result type (might be due to invalid IL or missing references)
			//IL_020b: 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_0218: Unknown result type (might be due to invalid IL or missing references)
			//IL_021d: Unknown result type (might be due to invalid IL or missing references)
			return new VRPoseBroadcast
			{
				ObjectId = b.ObjectId,
				BodyYaw = a.BodyYaw + Mathf.DeltaAngle(a.BodyYaw, b.BodyYaw) * t,
				BodyPos = Vector3.LerpUnclamped(a.BodyPos, b.BodyPos, t),
				HasBody = b.HasBody,
				LeftPos = Vector3.LerpUnclamped(a.LeftPos, b.LeftPos, t),
				LeftRot = Quaternion.SlerpUnclamped(a.LeftRot, b.LeftRot, t),
				RightPos = Vector3.LerpUnclamped(a.RightPos, b.RightPos, t),
				RightRot = Quaternion.SlerpUnclamped(a.RightRot, b.RightRot, t),
				FootLPos = Vector3.LerpUnclamped(a.FootLPos, b.FootLPos, t),
				FootLRot = Quaternion.SlerpUnclamped(a.FootLRot, b.FootLRot, t),
				FootLPole = Vector3.LerpUnclamped(a.FootLPole, b.FootLPole, t),
				FootRPos = Vector3.LerpUnclamped(a.FootRPos, b.FootRPos, t),
				FootRRot = Quaternion.SlerpUnclamped(a.FootRRot, b.FootRRot, t),
				FootRPole = Vector3.LerpUnclamped(a.FootRPole, b.FootRPole, t),
				Held = b.Held,
				HeldIsTool = b.HeldIsTool,
				HeldPos = Vector3.LerpUnclamped(a.HeldPos, b.HeldPos, t),
				HeldRot = Quaternion.SlerpUnclamped(a.HeldRot, b.HeldRot, t),
				LaserActive = b.LaserActive,
				LaserStart = Vector3.LerpUnclamped(a.LaserStart, b.LaserStart, t),
				LaserEnd = Vector3.LerpUnclamped(a.LaserEnd, b.LaserEnd, t),
				LineCount = b.LineCount,
				Line0 = b.Line0,
				Line1 = b.Line1,
				Line2 = b.Line2,
				Line3 = b.Line3
			};
		}

		private void Update()
		{
			try
			{
				if (VRConfig.MultiplayerVRSync.Value)
				{
					EnsureRegistered();
				}
				if (!VRConfig.MultiplayerVRSync.Value)
				{
					return;
				}
				try
				{
					if (InstanceFinder.IsServerStarted)
					{
						_relayActive = true;
					}
				}
				catch
				{
				}
				SendHello();
				if (_relayActive && Plugin.VREnabled)
				{
					SendPose();
				}
				SweepStale();
			}
			catch
			{
			}
		}

		private void EnsureRegistered()
		{
			try
			{
				if (!_clientRegistered && (Object)(object)InstanceFinder.ClientManager != (Object)null && InstanceFinder.IsClientStarted)
				{
					InstanceFinder.ClientManager.RegisterBroadcast<VRHelloResponse>((Action<VRHelloResponse, Channel>)OnClientHelloResponse);
					InstanceFinder.ClientManager.RegisterBroadcast<VRPoseBroadcast>((Action<VRPoseBroadcast, Channel>)OnClientPose);
					_clientRegistered = true;
				}
				if (!_serverRegistered && (Object)(object)InstanceFinder.ServerManager != (Object)null && InstanceFinder.IsServerStarted)
				{
					InstanceFinder.ServerManager.RegisterBroadcast<VRHelloBroadcast>((Action<NetworkConnection, VRHelloBroadcast, Channel>)OnServerHello, true);
					InstanceFinder.ServerManager.RegisterBroadcast<VRPoseBroadcast>((Action<NetworkConnection, VRPoseBroadcast, Channel>)OnServerPose, true);
					_serverRegistered = true;
				}
			}
			catch (Exception arg)
			{
				Plugin.Logger.LogError((object)$"VR network broadcast registration failed: {arg}");
			}
		}

		private void SendHello()
		{
			_helloTimer -= Time.unscaledDeltaTime;
			if (_helloTimer > 0f)
			{
				return;
			}
			_helloTimer = 3f;
			try
			{
				if (InstanceFinder.IsClientStarted)
				{
					int myObjectId = GetMyObjectId();
					if (myObjectId >= 0)
					{
						InstanceFinder.ClientManager.Broadcast<VRHelloBroadcast>(new VRHelloBroadcast
						{
							ObjectId = myObjectId
						}, (Channel)0);
					}
				}
			}
			catch
			{
			}
		}

		private void SendPose()
		{
			//IL_04dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_04e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_04e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_04e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_04f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_04f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_04f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_04fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0504: Unknown result type (might be due to invalid IL or missing references)
			//IL_071e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0720: Unknown result type (might be due to invalid IL or missing references)
			//IL_0730: Unknown result type (might be due to invalid IL or missing references)
			//IL_0732: Unknown result type (might be due to invalid IL or missing references)
			//IL_0738: Unknown result type (might be due to invalid IL or missing references)
			//IL_073d: Unknown result type (might be due to invalid IL or missing references)
			//IL_073f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0744: Unknown result type (might be due to invalid IL or missing references)
			//IL_0749: Unknown result type (might be due to invalid IL or missing references)
			//IL_0750: Unknown result type (might be due to invalid IL or missing references)
			//IL_0752: Unknown result type (might be due to invalid IL or missing references)
			//IL_0758: Unknown result type (might be due to invalid IL or missing references)
			//IL_075d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0762: Unknown result type (might be due to invalid IL or missing references)
			//IL_0769: Unknown result type (might be due to invalid IL or missing references)
			//IL_076b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0771: Unknown result type (might be due to invalid IL or missing references)
			//IL_0776: Unknown result type (might be due to invalid IL or missing references)
			//IL_0778: Unknown result type (might be due to invalid IL or missing references)
			//IL_077d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0782: Unknown result type (might be due to invalid IL or missing references)
			//IL_0789: Unknown result type (might be due to invalid IL or missing references)
			//IL_078b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0791: Unknown result type (might be due to invalid IL or missing references)
			//IL_0796: Unknown result type (might be due to invalid IL or missing references)
			//IL_079b: Unknown result type (might be due to invalid IL or missing references)
			//IL_07a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_07a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_07ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_07ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_07b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_07b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_07bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_07bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_07c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_07c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_07cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_07d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_07ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_07ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_07f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_07f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0805: Unknown result type (might be due to invalid IL or missing references)
			//IL_0807: Unknown result type (might be due to invalid IL or missing references)
			//IL_080e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0810: Unknown result type (might be due to invalid IL or missing references)
			//IL_0820: Unknown result type (might be due to invalid IL or missing references)
			//IL_0822: Unknown result type (might be due to invalid IL or missing references)
			//IL_0829: Unknown result type (might be due to invalid IL or missing references)
			//IL_082b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0832: Unknown result type (might be due to invalid IL or missing references)
			//IL_0834: Unknown result type (might be due to invalid IL or missing references)
			//IL_083b: Unknown result type (might be due to invalid IL or missing references)
			//IL_083d: 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_044b: Unknown result type (might be due to invalid IL or missing references)
			//IL_044d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0454: Unknown result type (might be due to invalid IL or missing references)
			//IL_0456: Unknown result type (might be due to invalid IL or missing references)
			//IL_045d: Unknown result type (might be due to invalid IL or missing references)
			//IL_045f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0466: Unknown result type (might be due to invalid IL or missing references)
			//IL_0468: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: 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_0115: 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_0127: Unknown result type (might be due to invalid IL or missing references)
			//IL_012c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0478: Unknown result type (might be due to invalid IL or missing references)
			//IL_047a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0488: Unknown result type (might be due to invalid IL or missing references)
			//IL_048d: Unknown result type (might be due to invalid IL or missing references)
			//IL_048f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0494: Unknown result type (might be due to invalid IL or missing references)
			//IL_0499: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_04b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_04b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_04bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_04c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_04c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_04cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_04d0: 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_01db: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_020c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0224: Unknown result type (might be due to invalid IL or missing references)
			//IL_0229: Unknown result type (might be due to invalid IL or missing references)
			//IL_022b: Unknown result type (might be due to invalid IL or missing references)
			//IL_022d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0235: Unknown result type (might be due to invalid IL or missing references)
			//IL_023a: Unknown result type (might be due to invalid IL or missing references)
			//IL_023c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0241: 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_024b: 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_0252: Unknown result type (might be due to invalid IL or missing references)
			//IL_0257: Unknown result type (might be due to invalid IL or missing references)
			//IL_025c: Unknown result type (might be due to invalid IL or missing references)
			//IL_025e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0263: Unknown result type (might be due to invalid IL or missing references)
			//IL_0265: Unknown result type (might be due to invalid IL or missing references)
			//IL_026a: 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)
			//IL_0271: 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_0617: Unknown result type (might be due to invalid IL or missing references)
			//IL_0619: Unknown result type (might be due to invalid IL or missing references)
			//IL_062b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0630: Unknown result type (might be due to invalid IL or missing references)
			//IL_0632: Unknown result type (might be due to invalid IL or missing references)
			//IL_0637: Unknown result type (might be due to invalid IL or missing references)
			//IL_063c: Unknown result type (might be due to invalid IL or missing references)
			//IL_063e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0640: Unknown result type (might be due to invalid IL or missing references)
			//IL_0652: Unknown result type (might be due to invalid IL or missing references)
			//IL_0657: Unknown result type (might be due to invalid IL or missing references)
			//IL_065c: Unknown result type (might be due to invalid IL or missing references)
			//IL_065e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0660: Unknown result type (might be due to invalid IL or missing references)
			//IL_0672: Unknown result type (might be due to invalid IL or missing references)
			//IL_0677: Unknown result type (might be due to invalid IL or missing references)
			//IL_0679: Unknown result type (might be due to invalid IL or missing references)
			//IL_067e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0683: Unknown result type (might be due to invalid IL or missing references)
			//IL_0685: Unknown result type (might be due to invalid IL or missing references)
			//IL_0687: Unknown result type (might be due to invalid IL or missing references)
			//IL_0699: Unknown result type (might be due to invalid IL or missing references)
			//IL_069e: Unknown result type (might be due to invalid IL or missing references)
			//IL_06a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_06a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_06aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_06ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_06ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_06c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_06c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_06ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_06cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_06ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_06e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_06e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_06e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_06ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_06f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0302: 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_030c: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_03bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_03db: Unknown result type (might be due to invalid IL or missing references)
			//IL_03dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e7: Unknown result type (might be due to invalid IL or missing references)
			_poseTimer -= Time.unscaledDeltaTime;
			if (_poseTimer > 0f)
			{
				return;
			}
			float num = Mathf.Clamp(VRConfig.VRSyncRate.Value, 5f, 60f);
			_poseTimer = 1f / num;
			try
			{
				Player localPlayer = Player.LocalPlayer;
				if ((Object)(object)localPlayer == (Object)null || (Object)(object)localPlayer.Hands == (Object)null || ((Object)(object)localPlayer.Dying != (Object)null && localPlayer.Dying.IsDead))
				{
					return;
				}
				try
				{
					if (Boat.IsDrivingLocally)
					{
						return;
					}
				}
				catch
				{
				}
				try
				{
					if (!XRSettings.isDeviceActive)
					{
						return;
					}
					InputDevice deviceAtXRNode = InputDevices.GetDeviceAtXRNode((XRNode)2);
					if (!((InputDevice)(ref deviceAtXRNode)).isValid)
					{
						return;
					}
					VRRig instance = VRRig.Instance;
					if ((Object)(object)instance != (Object)null && (Object)(object)instance.Root != (Object)null && (Object)(object)localPlayer.Camera != (Object)null && (Object)(object)localPlayer.Camera.CamTransform != (Object)null)
					{
						Quaternion val = instance.Root.rotation * VRActions.Instance.HeadRot;
						if (Mathf.Abs(Quaternion.Dot(localPlayer.Camera.CamTransform.rotation, val)) < 0.8f)
						{
							return;
						}
					}
				}
				catch
				{
					return;
				}
				Transform handBoneLeft = localPlayer.Hands.HandBoneLeft;
				Transform handBoneRight = localPlayer.Hands.HandBoneRight;
				if ((Object)(object)handBoneLeft == (Object)null || (Object)(object)handBoneRight == (Object)null || (Object)(object)localPlayer.Camera == (Object)null || (Object)(object)localPlayer.Camera.CamTransform == (Object)null)
				{
					return;
				}
				bool active = HowToFishBody.Active;
				Vector3 val2 = ((active && (Object)(object)localPlayer.Other != (Object)null && (Object)(object)localPlayer.Other.Transform != (Object)null) ? localPlayer.Other.Transform.position : (((Object)(object)localPlayer.Transform != (Object)null) ? localPlayer.Transform.position : Vector3.zero));
				float y = localPlayer.Camera.CamTransform.eulerAngles.y;
				Quaternion val3 = Quaternion.Euler(0f, y, 0f);
				Vector3 bodyPos = val2;
				bool held = false;
				bool flag = false;
				Vector3 heldPos = Vector3.zero;
				Quaternion heldRot = Quaternion.identity;
				bool laserActive = false;
				Vector3 laserStart = Vector3.zero;
				Vector3 laserEnd = Vector3.zero;
				int lineCount = 0;
				Vector3 val4 = Vector3.zero;
				Vector3 val5 = Vector3.zero;
				Vector3 val6 = Vector3.zero;
				Vector3 val7 = Vector3.zero;
				try
				{
					Item val8 = (((Object)(object)localPlayer.Holding != (Object)null) ? localPlayer.Holding.HeldItem : null);
					if ((Object)(object)val8 != (Object)null && (Object)(object)((Component)val8).transform != (Object)null && ((Component)val8).gameObject.activeInHierarchy)
					{
						held = true;
						flag = (Object)(object)val8.Tool != (Object)null;
						heldPos = Quaternion.Inverse(val3) * (((Component)val8).transform.position - val2);
						heldRot = Quaternion.Inverse(val3) * ((Component)val8).transform.rotation;
						if (flag && (Object)(object)val8.Tool != (Object)null)
						{
							try
							{
								if ((Object)(object)val8.Weapon != (Object)null && (Object)(object)val8.Weapon.Attachments != (Object)null)
								{
									LaserSight laserSight = val8.Weapon.Attachments._laserSight;
									if ((Object)(object)laserSight != (Object)null && ((Behaviour)laserSight).enabled && (Object)(object)laserSight._line != (Object)null && ((Renderer)laserSight._line).enabled && laserSight._line.positionCount >= 2)
									{
										laserActive = true;
										laserStart = Quaternion.Inverse(val3) * (laserSight._line.GetPosition(0) - val2);
										laserEnd = Quaternion.Inverse(val3) * (laserSight._line.GetPosition(1) - val2);
									}
								}
							}
							catch
							{
							}
							try
							{
								FishingRod val9 = (FishingRod)(object)((val8 is FishingRod) ? val8 : null);
								if (val9 != null && (Object)(object)val9._line != (Object)null && ((Renderer)val9._line).enabled)
								{
									int num2 = Mathf.Clamp(val9._line.positionCount, 0, 4);
									if (num2 > 0)
									{
										lineCount = num2;
										Vector3[] array = (Vector3[])(object)new Vector3[4] { val4, val5, val6, val7 };
										for (int i = 0; i < num2; i++)
										{
											array[i] = Quaternion.Inverse(val3) * (val9._line.GetPosition(i) - val2);
										}
										val4 = array[0];
										val5 = array[1];
										val6 = array[2];
										val7 = array[3];
									}
								}
							}
							catch
							{
							}
						}
					}
				}
				catch
				{
				}
				Vector3 footLPos = Vector3.zero;
				Vector3 footRPos = Vector3.zero;
				Vector3 footLPole = Vector3.zero;
				Vector3 footRPole = Vector3.zero;
				Quaternion footLRot = Quaternion.identity;
				Quaternion footRRot = Quaternion.identity;
				if (active && (Object)(object)localPlayer.Legs != (Object)null && localPlayer.Legs._legTargets != null && localPlayer.Legs._legTargets.Length >= 2 && localPlayer.Legs._ikPoles != null && localPlayer.Legs._ikPoles.Length >= 2 && localPlayer.Legs._footModels != null && localPlayer.Legs._footModels.Length >= 2 && (Object)(object)localPlayer.Legs._legTargets[0] != (Object)null && (Object)(object)localPlayer.Legs._legTargets[1] != (Object)null && (Object)(object)localPlayer.Legs._ikPoles[0] != (Object)null && (Object)(object)localPlayer.Legs._ikPoles[1] != (Object)null && (Object)(object)localPlayer.Legs._footModels[0] != (Object)null && (Object)(object)localPlayer.Legs._footModels[1] != (Object)null)
				{
					footLPos = Quaternion.Inverse(val3) * (localPlayer.Legs._legTargets[0].position - val2);
					footLRot = Quaternion.Inverse(val3) * localPlayer.Legs._footModels[0].rotation;
					footLPole = Quaternion.Inverse(val3) * (localPlayer.Legs._ikPoles[0].position - val2);
					footRPos = Quaternion.Inverse(val3) * (localPlayer.Legs._legTargets[1].position - val2);
					footRRot = Quaternion.Inverse(val3) * localPlayer.Legs._footModels[1].rotation;
					footRPole = Quaternion.Inverse(val3) * (localPlayer.Legs._ikPoles[1].position - val2);
				}
				_latest[_myObjectId] = new VRPoseBroadcast
				{
					ObjectId = _myObjectId,
					BodyYaw = y,
					BodyPos = bodyPos,
					HasBody = active,
					LeftPos = Quaternion.Inverse(val3) * (handBoneLeft.position - val2),
					LeftRot = Quaternion.Inverse(val3) * handBoneLeft.rotation,
					RightPos = Quaternion.Inverse(val3) * (handBoneRight.position - val2),
					RightRot = Quaternion.Inverse(val3) * handBoneRight.rotation,
					FootLPos = footLPos,
					FootLRot = footLRot,
					FootLPole = footLPole,
					FootRPos = footRPos,
					FootRRot = footRRot,
					FootRPole = footRPole,
					Held = held,
					HeldIsTool = flag,
					HeldPos = heldPos,
					HeldRot = heldRot,
					LaserActive = laserActive,
					LaserStart = laserStart,
					LaserEnd = laserEnd,
					LineCount = lineCount,
					Line0 = val4,
					Line1 = val5,
					Line2 = val6,
					Line3 = val7
				};
				_lastSeen[_myObjectId] = Time.unscaledTime;
				InstanceFinder.ClientManager.Broadcast<VRPoseBroadcast>(_latest[_myObjectId], (Channel)1);
			}
			catch
			{
			}
		}

		private int GetMyObjectId()
		{
			try
			{
				Player localPlayer = Player.LocalPlayer;
				if ((Object)(object)localPlayer == (Object)null)
				{
					return _myObjectId;
				}
				NetworkObject networkObject = ((NetworkBehaviour)localPlayer).NetworkObject;
				if ((Object)(object)networkObject == (Object)null)
				{
					return _myObjectId;
				}
				int objectId = networkObject.ObjectId;
				if (objectId != _myObjectId)
				{
					_myObjectId = objectId;
					_relayActive = false;
					_helloTimer = 0f;
				}
				return _myObjectId;
			}
			catch
			{
				return _myObjectId;
			}
		}

		private void OnServerHello(NetworkConnection conn, VRHelloBroadcast msg, Channel channel)
		{
			try
			{
				if (conn == (NetworkConnection)null || !conn.IsValid)
				{
					return;
				}
				bool num = _modded.Add(conn);
				InstanceFinder.ServerManager.Broadcast<VRHelloResponse>(conn, default(VRHelloResponse), true, (Channel)0);
				if (!num)
				{
					return;
				}
				foreach (KeyValuePair<int, VRPoseBroadcast> item in _latest)
				{
					if (item.Key != msg.ObjectId && (!_lastSeen.TryGetValue(item.Key, out var value) || !(Time.unscaledTime - value > 1.5f)))
					{
						InstanceFinder.ServerManager.Broadcast<VRPoseBroadcast>(conn, item.Value, true, (Channel)1);
					}
				}
			}
			catch
			{
			}
		}

		private void OnServerPose(NetworkConnection conn, VRPoseBroadcast msg, Channel channel)
		{
			try
			{
				_latest[msg.ObjectId] = msg;
				_lastSeen[msg.ObjectId] = Time.unscaledTime;
				AddSample(msg.ObjectId, msg);
				foreach (NetworkConnection item in _modded)
				{
					if (!(item == (NetworkConnection)null) && item.IsValid && !(item == conn))
					{
						InstanceFinder.ServerManager.Broadcast<VRPoseBroadcast>(item, msg, true, (Channel)1);
					}
				}
			}
			catch
			{
			}
		}

		private void OnClientHelloResponse(VRHelloResponse msg, Channel channel)
		{
			_relayActive = true;
		}

		private void OnClientPose(VRPoseBroadcast msg, Channel channel)
		{
			_latest[msg.ObjectId] = msg;
			_lastSeen[msg.ObjectId] = Time.unscaledTime;
			AddSample(msg.ObjectId, msg);
		}

		private void SweepStale()
		{
			if (_latest.Count == 0)
			{
				return;
			}
			List<int> list = new List<int>();
			foreach (KeyValuePair<int, float> item in _lastSeen)
			{
				if (Time.unscaledTime - item.Value > 3.5f)
				{
					list.Add(item.Key);
				}
			}
			foreach (int item2 in list)
			{
				_latest.Remove(item2);
				_lastSeen.Remove(item2);
			}
		}

		private void OnDestroy()
		{
			try
			{
				if (_clientRegistered && (Object)(object)InstanceFinder.ClientManager != (Object)null)
				{
					InstanceFinder.ClientManager.UnregisterBroadcast<VRHelloResponse>((Action<VRHelloResponse, Channel>)OnClientHelloResponse);
					InstanceFinder.ClientManager.UnregisterBroadcast<VRPoseBroadcast>((Action<VRPoseBroadcast, Channel>)OnClientPose);
				}
				if (_serverRegistered && (Object)(object)InstanceFinder.ServerManager != (Object)null)
				{
					InstanceFinder.ServerManager.UnregisterBroadcast<VRHelloBroadcast>((Action<NetworkConnection, VRHelloBroadcast, Channel>)OnServerHello);
					InstanceFinder.ServerManager.UnregisterBroadcast<VRPoseBroadcast>((Action<NetworkConnection, VRPoseBroadcast, Channel>)OnServerPose);
				}
			}
			catch
			{
			}
			_latest.Clear();
			_lastSeen.Clear();
		}
	}
	public struct VRHelloBroadcast : IBroadcast
	{
		public int ObjectId;
	}
	[StructLayout(LayoutKind.Sequential, Size = 1)]
	public struct VRHelloResponse : IBroadcast
	{
	}
	public struct VRPoseBroadcast : IBroadcast
	{
		public int ObjectId;

		public float BodyYaw;

		public Vector3 BodyPos;

		public bool HasBody;

		public Vector3 LeftPos;

		public Quaternion LeftRot;

		public Vector3 RightPos;

		public Quaternion RightRot;

		public Vector3 FootLPos;

		public Quaternion FootLRot;

		public Vector3 FootLPole;

		public Vector3 FootRPos;

		public Quaternion FootRRot;

		public Vector3 FootRPole;

		public bool Held;

		public bool HeldIsTool;

		public Vector3 HeldPos;

		public Quaternion HeldRot;

		public bool LaserActive;

		public Vector3 LaserStart;

		public Vector3 LaserEnd;

		public int LineCount;

		public Vector3 Line0;

		public Vector3 Line1;

		public Vector3 Line2;

		public Vector3 Line3;
	}
	public static class VRBroadcastSerializers
	{
		private static bool _registered;

		public static void Register()
		{
			if (_registered)
			{
				return;
			}
			_registered = true;
			try
			{
				GenericWriter<VRHelloBroadcast>.SetWrite((Action<Writer, VRHelloBroadcast>)delegate(Writer w, VRHelloBroadcast v)
				{
					w.WriteInt32(v.ObjectId);
				});
				GenericReader<VRHelloBroadcast>.SetRead((Func<Reader, VRHelloBroadcast>)((Reader r) => new VRHelloBroadcast
				{
					ObjectId = r.ReadInt32()
				}));
				GenericWriter<VRHelloResponse>.SetWrite((Action<Writer, VRHelloResponse>)delegate
				{
				});
				GenericReader<VRHelloResponse>.SetRead((Func<Reader, VRHelloResponse>)((Reader r) => default(VRHelloResponse)));
				GenericWriter<VRPoseBroadcast>.SetWrite((Action<Writer, VRPoseBroadcast>)delegate(Writer w, VRPoseBroadcast v)
				{
					//IL_001a: 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_003e: 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_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_006e: 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_0086: 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_00c2: Unknown result type (might be due to invalid IL or missing references)
					//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
					//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
					//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
					//IL_010a: Unknown result type (might be due to invalid IL or missing references)
					//IL_0116: 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_012e: Unknown result type (might be due to invalid IL or missing references)
					w.WriteInt32(v.ObjectId);
					w.WriteSingle(v.BodyYaw);
					w.WriteVector3(v.BodyPos);
					w.WriteBoolean(v.HasBody);
					w.WriteVector3(v.LeftPos);
					w.WriteQuaternion32(v.LeftRot);
					w.WriteVector3(v.RightPos);
					w.WriteQuaternion32(v.RightRot);
					w.WriteVector3(v.FootLPos);
					w.WriteQuaternion32(v.FootLRot);
					w.WriteVector3(v.FootLPole);
					w.WriteVector3(v.FootRPos);
					w.WriteQuaternion32(v.FootRRot);
					w.WriteVector3(v.FootRPole);
					w.WriteBoolean(v.Held);
					w.WriteBoolean(v.HeldIsTool);
					w.WriteVector3(v.HeldPos);
					w.WriteQuaternion32(v.HeldRot);
					w.WriteBoolean(v.LaserActive);
					w.WriteVector3(v.LaserStart);
					w.WriteVector3(v.LaserEnd);
					w.WriteInt32(v.LineCount);
					w.WriteVector3(v.Line0);
					w.WriteVector3(v.Line1);
					w.WriteVector3(v.Line2);
					w.WriteVector3(v.Line3);
				});
				GenericReader<VRPoseBroadcast>.SetRead((Func<Reader, VRPoseBroadcast>)((Reader r) => new VRPoseBroadcast
				{
					ObjectId = r.ReadInt32(),
					BodyYaw = r.ReadSingle(),
					BodyPos = r.ReadVector3(),
					HasBody = r.ReadBoolean(),
					LeftPos = r.ReadVector3(),
					LeftRot = r.ReadQuaternion32(),
					RightPos = r.ReadVector3(),
					RightRot = r.ReadQuaternion32(),
					FootLPos = r.ReadVector3(),
					FootLRot = r.ReadQuaternion32(),
					FootLPole = r.ReadVector3(),
					FootRPos = r.ReadVector3(),
					FootRRot = r.ReadQuaternion32(),
					FootRPole = r.ReadVector3(),
					Held = r.ReadBoolean(),
					HeldIsTool = r.ReadBoolean(),
					HeldPos = r.ReadVector3(),
					HeldRot = r.ReadQuaternion32(),
					LaserActive = r.ReadBoolean(),
					LaserStart = r.ReadVector3(),
					LaserEnd = r.ReadVector3(),
					LineCount = r.ReadInt32(),
					Line0 = r.ReadVector3(),
					Line1 = r.ReadVector3(),
					Line2 = r.ReadVector3(),
					Line3 = r.ReadVector3()
				}));
			}
			catch (Exception arg)
			{
				Plugin.Logger.LogError((object)$"VR pose serializer registration failed: {arg}");
			}
		}
	}
}
namespace HowToFishVR.Localization
{
	public static class Loc
	{
		public static void Register()
		{
		}

		public static string T(string key, string fallback)
		{
			return fallback;
		}
	}
}
namespace HowToFishVR.Input
{
	public class VRActions
	{
		private readonly InputActionMap _map;

		public readonly InputAction HeadPosition;

		public readonly InputAction HeadRotation;

		public readonly InputAction LeftPosition;

		public readonly InputAction LeftRotation;

		public readonly InputAction RightPosition;

		public readonly InputAction RightRotation;

		public readonly InputAction TurnAxis;

		public readonly InputAction TurnAxisY;

		public readonly InputAction MoveAxis;

		public readonly InputAction LeftGrip;

		public readonly InputAction RightGrip;

		public readonly InputAction LeftTrigger;

		public readonly InputAction RightTrigger;

		public readonly InputAction SprintButton;

		public readonly InputAction CrouchButton;

		public readonly InputAction Recenter;

		public static VRActions Instance { get; private set; }

		public Vector3 HeadPos => NodePos((XRNode)2, HeadPosition);

		public Quaternion HeadRot => NodeRot((XRNode)2, HeadRotation);

		public Vector3 LeftPos => NodePos((XRNode)4, LeftPosition);

		public Quaternion LeftRot => NodeRot((XRNode)4, LeftRotation);

		public Vector3 RightPos => NodePos((XRNode)5, RightPosition);

		public Quaternion RightRot => NodeRot((XRNode)5, RightRotation);

		public Vector3 MainHandPos => RightPos;

		public Quaternion MainHandRot => RightRot;

		public Vector3 OffHandPos => LeftPos;

		public Quaternion OffHandRot => LeftRot;

		public float OffHandGrip => LeftGrip.ReadValue<float>();

		public float MainHandGrip => RightGrip.ReadValue<float>();

		public static void Initialize()
		{
			if (Instance == null)
			{
				Instance = new VRActions();
				Instance._map.Enable();
			}
		}

		private VRActions()
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Expected O, but got Unknown
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_0130: Unknown result type (might be due to invalid IL or missing references)
			_map = new InputActionMap("HowToFishVR-XR");
			HeadPosition = InputActionSetupExtensions.AddAction(_map, "HeadPosition", (InputActionType)0, "<XRHMD>/centerEyePosition", (string)null, (string)null, (string)null, (string)null);
			HeadRotation = InputActionSetupExtensions.AddAction(_map, "HeadRotation", (InputActionType)0, "<XRHMD>/centerEyeRotation", (string)null, (string)null, (string)null, (string)null);
			LeftPosition = InputActionSetupExtensions.AddAction(_map, "LeftPosition", (InputActionType)0, "<XRController>{LeftHand}/devicePosition", (string)null, (string)null, (string)null, (string)null);
			LeftRotation = InputActionSetupExtensions.AddAction(_map, "LeftRotation", (InputActionType)0, "<XRController>{LeftHand}/deviceRotation", (string)null, (string)null, (string)null, (string)null);
			RightPosition = InputActionSetupExtensions.AddAction(_map, "RightPosition", (InputActionType)0, "<XRController>{RightHand}/devicePosition", (string)null, (string)null, (string)null, (string)null);
			RightRotation = InputActionSetupExtensions.AddAction(_map, "RightRotation", (InputActionType)0, "<XRController>{RightHand}/deviceRotation", (string)null, (string)null, (string)null, (string)null);
			TurnAxis = InputActionSetupExtensions.AddAction(_map, "TurnAxis", (InputActionType)0, (string)null, (string)null, (string)null, (string)null, (string)null);
			InputActionSetupExtensions.AddBinding(TurnAxis, "<XRController>{RightHand}/thumbstick/x", (string)null, (string)null, (string)null);
			TurnAxisY = InputActionSetupExtensions.AddAction(_map, "TurnAxisY", (InputActionType)0, (string)null, (string)null, (string)null, (string)null, (string)null);
			InputActionSetupExtensions.AddBinding(TurnAxisY, "<XRController>{RightHand}/thumbstick/y", (string)null, (string)null, (string)null);
			MoveAxis = InputActionSetupExtensions.AddAction(_map, "MoveAxis", (InputActionType)0, "<XRController>{LeftHand}/thumbstick", (string)null, (string)null, (string)null, (string)null);
			LeftGrip = InputActionSetupExtensions.AddAction(_map, "LeftGrip", (InputActionType)0, "<XRController>{LeftHand}/grip", (string)null, (string)null, (string)null, (string)null);
			RightGrip = InputActionSetupExtensions.AddAction(_map, "RightGrip", (InputActionType)0, "<XRController>{RightHand}/grip", (string)null, (string)null, (string)null, (string)null);
			LeftTrigger = InputActionSetupExtensions.AddAction(_map, "LeftTrigger", (InputActionType)0, "<XRController>{LeftHand}/trigger", (string)null, (string)null, (string)null, (string)null);
			RightTrigger = InputActionSetupExtensions.AddAction(_map, "RightTrigger", (InputActionType)0, "<XRController>{RightHand}/trigger", (string)null, (string)null, (string)null, (string)null);
			SprintButton = InputActionSetupExtensions.AddAction(_map, "SprintButton", (InputActionType)1, "<XRController>{LeftHand}/thumbstickClicked", (string)null, (string)null, (string)null, (string)null);
			CrouchButton = InputActionSetupExtensions.AddAction(_map, "CrouchButton", (InputActionType)1, "<XRController>{RightHand}/thumbstickClicked", (string)null, (string)null, (string)null, (string)null);
			Recenter = InputActionSetupExtensions.AddAction(_map, "Recenter", (InputActionType)1, "<XRController>{LeftHand}/secondaryButton", (string)null, (string)null, (string)null, (string)null);
		}

		private static Vector3 NodePos(XRNode node, InputAction fallback)
		{
			//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_0006: 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_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Invalid comparison between Unknown and I4
			//IL_0028: 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_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)
			InputDevice deviceAtXRNode = InputDevices.GetDeviceAtXRNode(node);
			if (((InputDevice)(ref deviceAtXRNode)).isValid)
			{
				Vector3 result = default(Vector3);
				if ((int)node == 2 && ((InputDevice)(ref deviceAtXRNode)).TryGetFeatureValue(CommonUsages.centerEyePosition, ref result))
				{
					return result;
				}
				Vector3 result2 = default(Vector3);
				if (((InputDevice)(ref deviceAtXRNode)).TryGetFeatureValue(CommonUsages.devicePosition, ref result2))
				{
					return result2;
				}
			}
			return fallback.ReadValue<Vector3>();
		}

		private static Quaternion NodeRot(XRNode node, InputAction fallback)
		{
			//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_0006: 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_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Invalid comparison between Unknown and I4
			//IL_0028: 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_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)
			InputDevice deviceAtXRNode = InputDevices.GetDeviceAtXRNode(node);
			if (((InputDevice)(ref deviceAtXRNode)).isValid)
			{
				Quaternion result = default(Quaternion);
				if ((int)node == 2 && ((InputDevice)(ref deviceAtXRNode)).TryGetFeatureValue(CommonUsages.centerEyeRotation, ref result))
				{
					return result;
				}
				Quaternion result2 = default(Quaternion);
				if (((InputDevice)(ref deviceAtXRNode)).TryGetFeatureValue(CommonUsages.deviceRotation, ref result2))
				{
					return result2;
				}
			}
			return ReadQuat(fallback);
		}

		private static Quaternion ReadQuat(InputAction a)
		{
			//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_0007: 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_0014: 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_002e: 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)
			Quaternion val = a.ReadValue<Quaternion>();
			if (val.x != 0f || val.y != 0f || val.z != 0f || val.w != 0f)
			{
				return val;
			}
			return Quaternion.identity;
		}
	}
	internal static class VRBindings
	{
		private static bool _injected;

		private static readonly (string action, string path)[] Map = new(string, string)[7]
		{
			("PlayerMove", "<XRController>{LeftHand}/thumbstick"),
			("PlayerRightClick", "<XRController>{LeftHand}/trigger"),
			("PlayerPickUp", "<XRController>{RightHand}/grip"),
			("PlayerJump", "<XRController>{RightHand}/primaryButton"),
			("WeaponReload", "<XRController>{LeftHand}/primaryButton"),
			("InventoryScroll", "<XRController>{RightHand}/thumbstick/y"),
			("Pause", "<XRController>{LeftHand}/secondaryButton")
		};

		private static readonly (string action, string path, string interactions)[] MapWithInteractions = new(string, string, string)[4]
		{
			("PlayerLeftClick", "<XRController>{RightHand}/trigger", "Press(pressPoint=0.25)"),
			("PlayerDrop", "<XRController>{RightHand}/secondaryButton", ""),
			("ChangeBait", "<XRController>{RightHand}/secondaryButton", "Tap()"),
			("WeaponInspect", "<XRController>{LeftHand}/grip", "Tap()")
		};

		public static bool TryInject()
		{
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: 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_013c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0141: 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_014a: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ee: 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_0086: 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_0150: Unknown result type (might be due to invalid IL or missing references)
			//IL_0155: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0214: 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_01c4: 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_0256: Unknown result type (might be due to invalid IL or missing references)
			if (_injected)
			{
				return true;
			}
			PlayerInput val = null;
			try
			{
				val = GameInfo.Input;
			}
			catch
			{
				return false;
			}
			InputActionAsset val2 = (((Object)(object)val != (Object)null) ? val.actions : null);
			if ((Object)(object)val2 == (Object)null)
			{
				return false;
			}
			(string, string)[] map = Map;
			for (int i = 0; i < map.Length; i++)
			{
				(string, string) tuple = map[i];
				string item = tuple.Item1;
				string item2 = tuple.Item2;
				InputAction val3 = val2.FindAction(item, false);
				if (val3 == null)
				{
					continue;
				}
				bool flag = false;
				Enumerator<InputBinding> enumerator = val3.bindings.GetEnumerator();
				try
				{
					while (enumerator.MoveNext())
					{
						InputBinding current = enumerator.Current;
						if (((InputBinding)(ref current)).path == item2)
						{
							flag = true;
							break;
						}
					}
				}
				finally
				{
					((IDisposable)enumerator/*cast due to .constrained prefix*/).Dispose();
				}
				if (!flag)
				{
					bool enabled = val3.enabled;
					if (enabled)
					{
						val3.Disable();
					}
					InputActionSetupExtensions.AddBinding(val3, item2, (string)null, (string)null, (string)null);
					if (enabled)
					{
						val3.Enable();
					}
				}
			}
			(string, string, string)[] mapWithInteractions = MapWithInteractions;
			for (int i = 0; i < mapWithInteractions.Length; i++)
			{
				(string, string, string) tuple2 = mapWithInteractions[i];
				string item3 = tuple2.Item1;
				string item4 = tuple2.Item2;
				string item5 = tuple2.Item3;
				InputAction val4 = val2.FindAction(item3, false);
				if (val4 == null)
				{
					continue;
				}
				bool flag2 = false;
				Enumerator<InputBinding> enumerator = val4.bindings.GetEnumerator();
				try
				{
					while (enumerator.MoveNext())
					{
						InputBinding current2 = enumerator.Current;
						if (((InputBinding)(ref current2)).path == item4 && (((InputBinding)(ref current2)).interactions ?? "") == (item5 ?? ""))
						{
							flag2 = true;
							break;
						}
					}
				}
				finally
				{
					((IDisposable)enumerator/*cast due to .constrained prefix*/).Dispose();
				}
				if (!flag2)
				{
					bool enabled2 = val4.enabled;
					if (enabled2)
					{
						val4.Disable();
					}
					InputActionSetupExtensions.AddBinding(val4, item4, item5, (string)null, (string)null);
					if (enabled2)
					{
						val4.Enable();
					}
				}
			}
			try
			{
				Enumerator<InputDevice> enumerator2 = InputSystem.devices.GetEnumerator();
				try
				{
					while (enumerator2.MoveNext())
					{
						InputDevice current3 = enumerator2.Current;
						string text = ((InputControl)current3).layout ?? "";
						InputDeviceDescription description = current3.description;
						string text2 = ((InputDeviceDescription)(ref description)).deviceClass ?? "";
						if (text.IndexOf("XR", StringComparison.OrdinalIgnoreCase) >= 0 || text2.IndexOf("XR", StringComparison.OrdinalIgnoreCase) >= 0)
						{
							InputUser.PerformPairingWithDevice(current3, val.user, (InputUserPairingOptions)0);
						}
					}
				}
				finally
				{
					((IDisposable)enumerator2/*cast due to .constrained prefix*/).Dispose();
				}
				val.neverAutoSwitchControlSchemes = true;
			}
			catch
			{
			}
			_injected = true;
			return true;
		}

		public static void Reset()
		{
			_injected = false;
		}

		public static void SuppressMouse()
		{
			try
			{
				Mouse current = Mouse.current;
				if (current != null && ((InputDevice)current).enabled)
				{
					InputSystem.DisableDevice((InputDevice)(object)current, false);
				}
			}
			catch
			{
			}
		}
	}
}
namespace HowToFishVR.Body
{
	internal sealed class BodyLifecycle : MonoBehaviour
	{
		private static BodyLifecycle _instance;

		private Player _lastPlayer;

		private int _reinitDelay;

		private bool _wasBound;

		internal static void Create()
		{
			//IL_0013: 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_001e: Expected O, but got Unknown
			if (!((Object)(object)_instance != (Object)null))
			{
				GameObject val = new GameObject("HowToFishVR BodyLifecycle");
				Object.DontDestroyOnLoad((Object)val);
				_instance = val.AddComponent<BodyLifecycle>();
			}
		}

		private void Update()
		{
			if (!Plugin.VREnabled)
			{
				return;
			}
			try
			{
				Tick();
			}
			catch
			{
			}
		}

		private void Tick()
		{
			if (VRConfig.BodyMode.Value != BodyMode.FullBodyIK)
			{
				_lastPlayer = null;
				_wasBound = false;
				return;
			}
			Player val;
			try
			{
				val = Player.LocalPlayer;
			}
			catch
			{
				val = null;
			}
			if ((Object)(object)val == (Object)null)
			{
				_lastPlayer = null;
				_wasBound = false;
				return;
			}
			if ((Object)(object)val != (Object)(object)_lastPlayer)
			{
				_lastPlayer = val;
				_reinitDelay = 1;
				_wasBound = false;
			}
			if (HowToFishBody.Active && (Object)(object)HowToFishBody.BoundPlayer == (Object)(object)val && HowToFishBody.RefsAlive())
			{
				if (!_wasBound)
				{
					_wasBound = true;
				}
				return;
			}
			_wasBound = false;
			if (_reinitDelay > 0)
			{
				_reinitDelay--;
			}
			else
			{
				if (!DepsReady(val))
				{
					return;
				}
				List<GameObject> otherObjects = val._otherObjects;
				if (otherObjects != null && otherObjects.Count != 0)
				{
					try
					{
						HowToFishBody.Build(val, otherObjects);
					}
					catch
					{
					}
				}
			}
		}

		private static bool DepsReady(Player p)
		{
			try
			{
				return (Object)(object)p.Transform != (Object)null && (Object)(object)p.Camera != (Object)null && (Object)(object)p.Arms != (Object)null && (Object)(object)p.Arms._ikRight != (Object)null && (Object)(object)p.Arms._ikLeft != (Object)null && (Object)(object)p.Hands != (Object)null && (Object)(object)p.Hands.HandBoneLeft != (Object)null && (Object)(object)p.Hands.HandBoneRight != (Object)null && (Object)(object)p.Other != (Object)null && (Object)(object)p.Other._transform != (Object)null && p._otherObjects != null && p._otherObjects.Count > 0;
			}
			catch
			{
				return false;
			}
		}
	}
	[HarmonyPatch]
	internal static class BodyPatches
	{
		private static List<GameObject> _stashed;

		[HarmonyPrefix]
		[HarmonyPatch(typeof(Player), "InitializePlayer")]
		private static void SaveBodyPrefix(Player __instance)
		{
			_stashed = null;
			if (Plugin.VREnabled && ((NetworkBehaviour)__instance).Owner.IsLocalClient && __instance._otherObjects != null)
			{
				_stashed = __instance._otherObjects;
				__instance._otherObjects = new List<GameObject>();
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(Player), "InitializePlayer")]
		private static void SaveBodyPostfix(Player __instance)
		{
			if (_stashed == null)
			{
				return;
			}
			List<GameObject> stashed = _stashed;
			_stashed = null;
			__instance._otherObjects = stashed;
			HowToFishBody.Store(__instance, stashed);
			if (Plugin.VREnabled && FullBodyActive())
			{
				HowToFishBody.Build(__instance, stashed);
			}
			if (!Plugin.VREnabled || !((NetworkBehaviour)__instance).Owner.IsLocalClient)
			{
				return;
			}
			try
			{
				VRRig.Instance?.OnRespawn();
			}
			catch
			{
			}
			if (!FullBodyActive())
			{
				return;
			}
			try
			{
				ArmRig.Setup(__instance);
			}
			catch
			{
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(PlayerDying), "DeathEffects")]
		private static void HideOnDeath(PlayerDying __instance)
		{
			if (Plugin.VREnabled && FullBodyActive() && (Object)(object)__instance._player == (Object)(object)Player.LocalPlayer)
			{
				HowToFishBody.SetVisible(visible: false);
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(PlayerDying), "ResurrectEffect")]
		private static void ShowOnResurrect(PlayerDying __instance)
		{
			if (!Plugin.VREnabled || (Object)(object)__instance._player != (Object)(object)Player.LocalPlayer)
			{
				return;
			}
			if (FullBodyActive())
			{
				HowToFishBody.SetVisible(visible: true);
			}
			VRRig instance = VRRig.Instance;
			if ((Object)(object)instance != (Object)null)
			{
				instance.OnRespawn();
			}
			try
			{
				ArmRig.Setup(__instance._player);
			}
			catch
			{
			}
			try
			{
				LocalBodyDriver component = ((Component)__instance._player).GetComponent<LocalBodyDriver>();
				if ((Object)(object)component != (Object)null)
				{
					component.Sync();
				}
			}
			catch
			{
			}
			try
			{
				HowToFishBody.ApplyBodyMode();
			}
			catch
			{
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(Player), "OnStopClient")]
		private static void ForgetOnDisconnect(Player __instance)
		{
			if (Plugin.VREnabled && (Object)(object)__instance == (Object)(object)Player.LocalPlayer)
			{
				HowToFishBody.Clear();
			}
		}

		private static bool FullBodyActive()
		{
			return VRConfig.BodyMode.Value == BodyMode.FullBodyIK;
		}
	}
	[HarmonyPatch(typeof(PlayerBody))]
	internal static class PlayerBodyPatches
	{
		[HarmonyPostfix]
		[HarmonyPatch("LateUpdate")]
		private static void SnapBodyWithTurn(PlayerBody __instance)
		{
			//IL_0068: 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_0070: 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)
			//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_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			if (!Plugin.VREnabled)
			{
				return;
			}
			VRRig instance = VRRig.Instance;
			if ((Object)(object)instance == (Object)null || !instance.SnapTurned)
			{
				return;
			}
			try
			{
				if (!((Object)(object)__instance._player == (Object)null) && !((Object)(object)__instance._player != (Object)(object)Player.LocalPlayer))
				{
					float snapTurnYaw = instance.SnapTurnYaw;
					float num;
					if (!((Object)(object)instance.Head != (Object)null))
					{
						num = 0f;
					}
					else
					{
						Quaternion localRotation = instance.Head.localRotation;
						num = ((Quaternion)(ref localRotation)).eulerAngles.x;
					}
					float num2 = num;
					__instance._swayRot = Quaternion.Euler(0f, snapTurnYaw, 0f) * __instance._bendRot;
					__instance._headRot = Quaternion.Euler(num2, snapTurnYaw, 0f);
					__instance._swayAngVel = Vector3.zero;
					__instance._headAngVel = Vector3.zero;
					if ((Object)(object)__instance._lowerBody != (Object)null)
					{
						__instance._lowerBody.rotation = __instance._swayRot;
					}
					if ((Object)(object)__instance._head != (Object)null)
					{
						__instance._head.rotation = __instance._headRot;
					}
				}
			}
			catch
			{
			}
		}
	}
	internal static class HowToFishBody
	{
		private static Player _player;

		private static List<GameObject> _bodyObjects;

		private static LocalBodyDriver _driver;

		public static bool Active { get; private set; }

		public static List<GameObject> BodyObjects => _bodyObjects;

		public static Player BoundPlayer => _player;

		public static bool RefsAlive()
		{
			try
			{
				if ((Object)(object)_player == (Object)null || (Object)(object)_driver == (Object)null || _bodyObjects == null)
				{
					return false;
				}
				for (int i = 0; i < _bodyObjects.Count; i++)
				{
					if ((Object)(object)_bodyObjects[i] == (Object)null)
					{
						return false;
					}
				}
				if ((Object)(object)_player.Other == (Object)null || (Object)(object)_player.Other._transform == (Object)null)
				{
					return false;
				}
				PlayerArms arms = _player.Arms;
				if ((Object)(object)arms == (Object)null || (Object)(object)arms._ikRight == (Object)null || (Object)(object)arms._ikLeft == (Object)null)
				{
					return false;
				}
				PlayerHands hands = _player.Hands;
				if ((Object)(object)hands == (Object)null || (Object)(object)hands.HandBoneLeft == (Object)null || (Object)(object)hands.HandBoneRight == (Object)null)
				{
					return false;
				}
				return true;
			}
			catch
			{
				return false;
			}
		}

		internal static void Store(Player player, List<GameObject> bodyObjects)
		{
			_player = player;
			_bodyObjects = bodyObjects;
		}

		internal static void Build(Player player, List<GameObject> bodyObjects)
		{
			try
			{
				foreach (GameObject bodyObject in bodyObjects)
				{
					if ((Object)(object)bodyObject != (Object)null)
					{
						bodyObject.SetActive(true);
					}
				}
				EnableAllowedComponents(player);
				player.Skin.InitializeOther();
				player.Body.ToggleOldModel(player._isBean.Value);
				OtherPlayer other = player.Other;
				if ((Object)(object)other._col != (Object)null)
				{
					((Collider)other._col).enabled = false;
				}
				if ((Object)(object)player.Body._nameTextCanvasHolder != (Object)null)
				{
					((Component)player.Body._nameTextCanvasHolder).gameObject.SetActive(false);
				}
				if ((Object)(object)other._otherPlayerCanvasHolder != (Object)null)
				{
					((Component)other._otherPlayerCanvasHolder).gameObject.SetActive(false);
				}
				HandleHead(player);
				_driver = ((Component)player).GetComponent<LocalBodyDriver>();
				if ((Object)(object)_driver == (Object)null)
				{
					_driver = ((Component)player).gameObject.AddComponent<LocalBodyDriver>();
				}
				((Behaviour)_driver).enabled = true;
				_driver.Init(player);
				ArmRig.Setup(player);
				_player = player;
				_bodyObjects = bodyObjects;
				Active = true;
			}
			catch
			{
				Active = false;
			}
		}

		internal static void SetVisible(bool visible)
		{
			if (!Active || _bodyObjects == null)
			{
				return;
			}
			foreach (GameObject bodyObject in _bodyObjects)
			{
				if ((Object)(object)bodyObject != (Object)null)
				{
					bodyObject.SetActive(visible);
				}
			}
			if ((Object)(object)_player != (Object)null && (Object)(object)_player.Other._transform != (Object)null)
			{
				((Component)_player.Other._transform).gameObject.SetActive(visible);
			}
			if (!visible || !((Object)(object)_player != (Object)null))
			{
				return;
			}
			try
			{
				_player.Body.Reset();
				_player.Legs.Reset();
			}
			catch
			{
			}
			try
			{
				((Component)_player).GetComponent<LocalBodyDriver>()?.Sync();
			}
			catch
			{
			}
			try
			{
				ArmRig.Setup(_player);
			}
			catch
			{
			}
		}

		internal static void Clear()
		{
			Active = false;
			_player = null;
			_bodyObjects = null;
		}

		internal static void ApplyBodyMode()
		{
			if (VRConfig.BodyMode.Value != BodyMode.FullBodyIK)
			{
				SetVisible(visible: false);
				Active = false;
				if ((Object)(object)_driver != (Object)null)
				{
					((Behaviour)_driver).enabled = false;
				}
				return;
			}
			bool flag = _bodyObjects != null;
			if (flag)
			{
				foreach (GameObject bodyObject in _bodyObjects)
				{
					if ((Object)(object)bodyObject == (Object)null)
					{
						flag = false;
						break;
					}
				}
			}
			bool flag2 = (Object)(object)_player != (Object)null;
			if (Active && flag)
			{
				SetVisible(visible: true);
				return;
			}
			if (flag && flag2)
			{
				try
				{
					Build(_player, _bodyObjects);
					return;
				}
				catch
				{
					return;
				}
			}
			Player localPlayer = Player.LocalPlayer;
			if (!((Object)(object)localPlayer != (Object)null) || localPlayer._otherObjects == null || localPlayer._otherObjects.Count <= 0)
			{
				return;
			}
			try
			{
				Build(localPlayer, localPlayer._otherObjects);
			}
			catch
			{
			}
		}

		private static void HandleHead(Player player)
		{
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			Transform val = null;
			try
			{
				val = player.Body.Head;
			}
			catch
			{
			}
			if ((Object)(object)val == (Object)null)
			{
				return;
			}
			Transform val2 = (((Object)(object)player.Other._transform != (Object)null) ? player.Other._transform : val.root);
			try
			{
				if ((Object)(object)val2.Find("VRShadowHead") == (Object)null)
				{
					CreateShadowHead(val, val2);
				}
			}
			catch
			{
			}
			val.localScale = Vector3.zero;
		}

		private static void CreateShadowHead(Transform head, Transform parent)
		{
			//IL_0024: 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_003b: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				Transform transform = Object.Instantiate<GameObject>(((Component)head).gameObject, head.parent).transform;
				((Object)transform).name = "VRShadowHead";
				transform.localPosition = head.localPosition;
				transform.localRotation = head.localRotation;
				transform.localScale = Vector3.one;
				Dictionary<Transform, Transform> dictionary = new Dictionary<Transform, Transform>();
				Transform[] componentsInChildren = ((Component)head).GetComponentsInChildren<Transform>(true);
				Transform[] componentsInChildren2 = ((Component)transform).GetComponentsInChildren<Transform>(true);
				if (componentsInChildren.Length == componentsInChildren2.Length)
				{
					for (int i = 0; i < componentsInChildren.Length; i++)
					{
						dictionary[componentsInChildren[i]] = componentsInChildren2[i];
					}
					Renderer[] componentsInChildren3 = ((Component)transform).GetComponentsInChildren<Renderer>(true);
					foreach (Renderer val in componentsInChildren3)
					{
						if ((Object)(object)val != (Object)null)
						{
							val.shadowCastingMode = (ShadowCastingMode)3;
						}
					}
					SkinnedMeshRenderer[] componentsInChildren4 = ((Component)parent).GetComponentsInChildren<SkinnedMeshRenderer>(true);
					foreach (SkinnedMeshRenderer val2 in componentsInChildren4)
					{
						if ((Object)(object)val2 == (Object)null || (Object)(object)val2.sharedMesh == (Object)null || val2.bones == null || !RidesHead(val2.bones, dictionary))
						{
							continue;
						}
						SkinnedMeshRenderer component = Object.Instantiate<GameObject>(((Component)val2).gameObject, ((Component)val2).transform.parent).GetComponent<SkinnedMeshRenderer>();
						if ((Object)(object)component == (Object)null)
						{
							continue;
						}
						((Object)component).name = ((Object)val2).name + " (shadow head)";
						Transform[] bones = component.bones;
						for (int k = 0; k < bones.Length; k++)
						{
							if ((Object)(object)bones[k] != (Object)null && dictionary.TryGetValue(bones[k], out var value))
							{
								bones[k] = value;
							}
						}
						component.bones = bones;
						if ((Object)(object)component.rootBone != (Object)null && dictionary.TryGetValue(component.rootBone, out var value2))
						{
							component.rootBone = value2;
						}
						((Renderer)component).shadowCastingMode = (ShadowCastingMode)3;
					}
				}
				((Component)transform).gameObject.AddComponent<ShadowHeadFollow>().Follow(head);
			}
			catch
			{
			}
		}

		private static bool RidesHead(Transform[] bones, Dictionary<Transform, Transform> map)
		{
			foreach (Transform val in bones)
			{
				if ((Object)(object)val != (Object)null && map.ContainsKey(val))
				{
					return true;
				}
			}
			return false;
		}

		private static void EnableAllowedComponents(Player player)
		{
			HashSet<string> hashSet = new HashSet<string>(StringComparer.OrdinalIgnoreCase) { "OtherPlayer", "PlayerBody", "PlayerLegs", "PlayerArms", "IK" };
			MonoBehaviour[] disableWhenLocal = player._disableWhenLocal;
			foreach (MonoBehaviour val in disableWhenLocal)
			{
				if (!((Object)(object)val == (Object)null) && hashSet.Contains(((object)val).GetType().Name))
				{
					((Behaviour)val).enabled = true;
				}
			}
		}
	}
	internal sealed class ShadowHeadFollow : MonoBehaviour
	{
		private Transform _head;

		internal void Follow(Transform head)
		{
			_head = head;
		}

		private void LateUpdate()
		{
			//IL_001a: 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)
			if ((Object)(object)_head != (Object)null)
			{
				((Component)this).transform.localPosition = _head.localPosition;
				((Component)this).transform.localRotation = _head.localRotation;
			}
		}
	}
	internal sealed class LocalBodyDriver : MonoBehaviour
	{
		private Player _player;

		private OtherPlayer _other;

		private bool _wasOnBoat;

		private bool _bodyHidden;

		internal void Init(Player player)
		{
			_player = player;
			_other = player.Other;
			_wasOnBoat = player.Movement.OnBoat;
			_other._transform.SetParent(player.Transform, false);
			Sync();
		}

		private void Update()
		{
			if (!((Object)(object)_player == (Object)null) && !((Object)(object)_other == (Object)null) && HowToFishBody.Active)
			{
				Sync();
			}
		}

		internal void Sync()
		{
			//IL_01a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0193: 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_013e: Unknown result type (might be due to invalid IL or missing references)
			//IL_014a: 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_0158: Unknown result type (might be due to invalid IL or missing references)
			//IL_016a: Unknown result type (might be due to invalid IL or missing references)
			//IL_016f: 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_01c2: 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_01df: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f0: 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_021c: Unknown result type (might be due to invalid IL or missing references)
			//IL_024f: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if ((Object)(object)_player.CamObject == (Object)null || (Object)(object)_player.Transform == (Object)null || (Object)(object)_other._transform == (Object)null)
				{
					return;
				}
				if ((Object)(object)_other._transform.parent != (Object)(object)_player.Transform)
				{
					_other._transform.SetParent(_player.Transform, false);
				}
				bool onBoat = _player.Movement.OnBoat;
				if (onBoat != _wasOnBoat)
				{
					_wasOnBoat = onBoat;
					_other._velSamples.Clear();
				}
				_other.OnBoat = onBoat;
				bool flag = false;
				try
				{
					flag = Boat.IsDrivingLocally;
				}
				catch
				{
				}
				if (flag != _bodyHidden)
				{
					_bodyHidden = flag;
					HowToFishBody.SetVisible(!flag);
					if (!flag)
					{
						try
						{
							VRRig.Instance?.OnRespawn();
						}
						catch
						{
						}
						try
						{
							ArmRig.Setup(_player);
						}
						catch
						{
						}
					}
				}
				VRRig instance = VRRig.Instance;
				float y;
				float x;
				if ((Object)(object)instance != (Object)null && (Object)(object)instance.Root != (Object)null && (Object)(object)instance.Head != (Object)null)
				{
					Quaternion val = instance.Root.rotation * instance.Head.localRotation;
					y = ((Quaternion)(ref val)).eulerAngles.y;
					val = instance.Head.localRotation;
					x = ((Quaternion)(ref val)).eulerAngles.x;
				}
				else
				{
					Vector3 val2 = (((Object)(object)_player.CamObject != (Object)null) ? _player.CamObject.eulerAngles : Vector3.zero);
					y = val2.y;
					x = val2.x;
				}
				Quaternion val3 = Quaternion.Euler(0f, y, 0f);
				_other._transform.localPosition = _player.Transform.InverseTransformDirection(val3 * VRConfig.BodyOffset.Value);
				_other._transform.localRotation = Quaternion.Inverse(_player.Transform.rotation) * val3;
				if ((Object)(object)_other._camProxy != (Object)null)
				{
					_other._camProxy.localRotation = Quaternion.Euler(x, 0f, 0f);
				}
			}
			catch
			{
			}
		}
	}
	internal static class ArmRig
	{
		private static IK _ikRight;

		private static IK _ikLeft;

		private static Transform _poleRight;

		private static Transform _poleLeft;

		private static Player _player;

		private static Vector3 _prevPoleR;

		private static Vector3 _prevPoleL;

		private static bool _havePrevR;

		private static bool _havePrevL;

		private const float ElbowPoleFollow = 50f;

		private const float ElbowZDistanceStart = 0.6f;

		private const float ElbowXDistanceStart = 0.1f;

		private static IK _lastIkR;

		private static IK _lastIkL;

		private static readonly Quaternion[] _shoulderLocalDelta = (Quaternion[])(object)new Quaternion[2]
		{
			Quaternion.identity,
			Quaternion.identity
		};

		private static readonly Quaternion[] _shoulderLastAppliedLocal = (Quaternion[])(object)new Quaternion[2]
		{
			Quaternion.identity,
			Quaternion.identity
		};

		private static readonly bool[] _shoulderApplied = new bool[2];

		internal static void Setup(Player player)
		{
			//IL_0034: 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_003a: 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)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			RestoreShoulderBase(_ikLeft, 0);
			RestoreShoulderBase(_ikRight, 1);
			_player = player;
			_havePrevR = (_havePrevL = false);
			_shoulderLocalDelta[0] = (_shoulderLocalDelta[1] = Quaternion.identity);
			_shoulderApplied[0] = (_shoulderApplied[1] = false);
			Refresh(player);
		}

		internal static void SolveCurrentPose(Player player)
		{
			if (!HowToFishBody.Active || (Object)(object)player == (Object)null || (Object)(object)player != (Object)(object)HowToFishBody.BoundPlayer)
			{
				return;
			}
			try
			{
				Refresh(player);
				IK ikRight = _ikRight;
				if (ikRight != null)
				{
					ikRight.ResolveIK(false);
				}
				IK ikLeft = _ikLeft;
				if (ikLeft != null)
				{
					ikLeft.ResolveIK(false);
				}
			}
			catch
			{
			}
		}

		internal static void PrepareForSnapTurn()
		{
			try
			{
				RestoreShoulderBase(_ikLeft, 0);
				RestoreShoulderBase(_ikRight, 1);
				if ((Object)(object)_ikLeft != (Object)null)
				{
					_ikLeft._stopResolving = false;
				}
				if ((Object)(object)_ikRight != (Object)null)
				{
					_ikRight._stopResolving = false;
				}
			}
			catch
			{
			}
			_havePrevR = (_havePrevL = false);
		}

		internal static void Refresh(Player player)
		{
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if ((Object)(object)player == (Object)null)
				{
					return;
				}
				PlayerArms arms = player.Arms;
				if ((Object)(object)arms == (Object)null)
				{
					return;
				}
				IK ikRight = arms._ikRight;
				IK ikLeft = arms._ikLeft;
				if ((Object)(object)ikRight == (Object)null || (Object)(object)ikLeft == (Object)null)
				{
					return;
				}
				if ((Object)(object)ikRight != (Object)(object)_lastIkR || (Object)(object)ikLeft != (Object)(object)_lastIkL)
				{
					RestoreShoulderBase(_ikLeft, 0);
					RestoreShoulderBase(_ikRight, 1);
					_havePrevR = (_havePrevL = false);
					_lastIkR = ikRight;
					_lastIkL = ikLeft;
				}
				_ikRight = ikRight;
				_ikLeft = ikLeft;
				if ((Object)(object)_poleRight == (Object)null || (Object)(object)_poleLeft == (Object)null)
				{
					if ((Object)(object)_poleRight == (Object)null)
					{
						_poleRight = new GameObject("VRRightElbowPole").transform;
					}
					if ((Object)(object)_poleLeft == (Object)null)
					{
						_poleLeft = new GameObject("VRLeftElbowPole").transform;
					}
					try
					{
						_poleRight.SetParent(player.Transform, false);
						_poleLeft.SetParent(player.Transform, false);
					}
					catch
					{
					}
					_havePrevR = (_havePrevL = false);
				}
				PlayerHands hands = player.Hands;
				if (!((Object)(object)hands == (Object)null) && !((Object)(object)hands.HandBoneRight == (Object)null) && !((Object)(object)hands.HandBoneLeft == (Object)null))
				{
					_ikRight.Target = hands.HandBoneRight;
					_ikLeft.Target = hands.HandBoneLeft;
					if (!((Behaviour)_ikRight).enabled)
					{
						((Behaviour)_ikRight).enabled = true;
					}
					if (!((Behaviour)_ikLeft).enabled)
					{
						((Behaviour)_ikLeft).enabled = true;
					}
					_ikRight._enableStretch = false;
					_ikRight._snapBackStrength = 0f;
					_ikRight._iterations = 6;
					_ikRight._pole = _poleRight;
					_ikLeft._enableStretch = false;
					_ikLeft._snapBackStrength = 0f;
					_ikLeft._iterations = 6;
					_ikLeft._pole = _poleLeft;
					PlacePoles(player);
				}
			}
			catch
			{
			}
		}

		private static void PlacePoles(Player player)
		{
			//IL_003b: 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_004f: 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_0075: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				Transform val = (((Object)(object)player.Other != (Object)null && (Object)(object)player.Other._transform != (Object)null) ? player.Other._transform : player.Transform);
				Quaternion torso = Quaternion.Euler(0f, val.eulerAngles.y, 0f);
				PlaceOnePole(_ikRight, _poleRight, torso, left: false, ref _prevPoleR, ref _havePrevR);
				PlaceOnePole(_ikLeft, _poleLeft, torso, left: true, ref _prevPoleL, ref _havePrevL);
			}
			catch
			{
			}
		}

		private static void PlaceOnePole(IK ik, Transform pole, Quaternion torso, bool left, ref Vector3 prev, ref bool havePrev)
		{
			//IL_0063: 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_0068: 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_007a: 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_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: 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_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: 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_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: 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_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: 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_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)ik == (Object)null || (Object)(object)pole == (Object)null)
			{
				return;
			}
			Transform[] bones = ik._bones;
			if (bones == null || bones.Length < 3 || (Object)(object)bones[0] == (Object)null || (Object)(object)bones[1] == (Object)null || (Object)(object)bones[2] == (Object)null)
			{
				return;
			}
			Vector3 handPos = (((Object)(object)ik.Target != (Object)null) ? ik.Target.position : bones[2].position);
			Quaternion handRot = (((Object)(object)ik.Target != (Object)null) ? ik.Target.rotation : bones[2].rotation);
			float num = Vector3.Distance(bones[0].position, bones[1].position) + Vector3.Distance(bones[1].position, bones[2].position);
			if (!(num < 0.0001f))
			{
				SlideShoulder(bones[0], handPos, num, left);
				Vector3 val = ComputeElbowPole(bones[0].position, handPos, torso, handRot, num, left);
				if (havePrev)
				{
					val = Vector3.Lerp(prev, val, 1f - Mathf.Exp(-50f * Time.unscaledDeltaTime));
				}
				prev = val;
				havePrev = true;
				pole.position = val;
			}
		}

		internal static Vector3 ComputeElbowPole(Vector3 shoulderPos, Vector3 handPos, Quaternion torso, Quaternion handRot, float armLength, bool left)
		{
			//IL_0024: 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_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_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_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: 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_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: 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)
			//IL_00e7: 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)
			//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)
			float num = (left ? (-1f) : 1f);
			float num2 = 1f / Mathf.Max(armLength, 0.001f);
			Vector3 val = Quaternion.Inverse(torso) * (handPos - shoulderPos) * num2;
			float num3 = 0.85f;
			float num4 = 0.22f;
			float num5 = 0.28f;
			float num6 = Mathf.Clamp01(0.55f - val.z);
			num3 += num6 * 0.2f;
			num4 += num6 * 0.25f;
			float num7 = Mathf.Max((0f - num) * val.x, 0f);
			num4 += num7 * 0.55f;
			num3 = Mathf.Max(num3 - Mathf.Clamp01(val.y) * 0.45f, 0.15f);
			Vector3 val2 = torso * new Vector3(num * num4, 0f - num3, 0f - num5);
			Vector3 normalized = ((Vector3)(ref val2)).normalized;
			return (shoulderPos + handPos) * 0.5f + normalized * (armLength * 0.5f);
		}

		private static void SlideShoulder(Transform upperArm, Vector3 handPos, float armLength, bool left)
		{
			//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_0044: 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_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: 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_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: 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_0114: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: 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_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_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0130: 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_0136: 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_014b: Unknown result type (might be due to invalid IL or missing references)
			//IL_014d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0159: Unknown result type (might be due to invalid IL or missing references)
			//IL_015e: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				Transform parent = upperArm.parent;
				if ((Object)(object)parent == (Object)null || parent.childCount > 2)
				{
					return;
				}
				int num = ((!left) ? 1 : 0);
				RestoreShoulderBase(left ? _ikLeft : _ikRight, num);
				Vector3 position = upperArm.position;
				float num2 = Vector3.Distance(handPos, position);
				float num3 = armLength * 0.85f;
				float num4 = ((num3 > 0.0001f) ? (Mathf.Clamp(num2 - armLength * 0.5f, 0f, num3) / num3) : 0f);
				if (!(num4 <= 0.0001f))
				{
					Vector3 val = handPos - position;
					Vector3 val2 = position + ((Vector3)(ref val)).normalized * (num4 * armLength * 0.08f);
					Vector3 val3 = position - parent.position;
					Vector3 val4 = val2 - parent.position;
					if (!(((Vector3)(ref val3)).sqrMagnitude < 1E-06f) && !(((Vector3)(ref val4)).sqrMagnitude < 1E-06f))
					{
						Quaternion val5 = Quaternion.FromToRotation(val3, val4);
						Quaternion val6 = (((Object)(object)parent.parent != (Object)null) ? parent.parent.rotation : Quaternion.identity);
						Quaternion val7 = Quaternion.Inverse(val6) * val5 * val6;
						parent.localRotation = val7 * parent.localRotation;
						_shoulderLocalDelta[num] = val7;
						_shoulderLastAppliedLocal[num] = parent.localRotation;
						_shoulderApplied[num] = true;
					}
				}
			}
			catch
			{
			}
		}

		private static void RestoreShoulderBase(IK ik, int i)
		{
			//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_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				Transform[] array = (((Object)(object)ik != (Object)null) ? ik._bones : null);
				Transform val = ((array != null && array.Length != 0 && (Object)(object)array[0] != (Object)null) ? array[0].parent : null);
				if ((Object)(object)val != (Object)null && _shoulderApplied[i] && Quaternion.Angle(val.localRotation, _shoulderLastAppliedLocal[i]) < 0.01f)
				{
					val.localRotation = Quaternion.Inverse(_shoulderLocalDelta[i]) * val.localRotation;
				}
			}
			catch
			{
			}
			_shoulderLocalDelta[i] = Quaternion.identity;
			_shoulderApplied[i] = false;
		}
	}
	[DefaultExecutionOrder(500)]
	public class RemoteBodyDriver : MonoBehaviour
	{
		private class RemotePlayer
		{
			public Player Player;

			public Transform Root;

			public Transform HandR;

			public Transform HandL;

			public IK IkR;

			public IK IkL;

			public Transform PoleR;

			public Transform PoleL;

			public Item PinnedItem;
		}

		private readonly Dictionary<int, RemotePlayer> _players = new Dictionary<int, RemotePlayer>();

		private float _rescanTimer = 0.5f;

		public static RemoteBodyDriver Create()
		{
			//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_0010: Expected O, but got Unknown
			GameObject val = new GameObject("HowToFishVR RemoteBodyDriver");
			Object.DontDestroyOnLoad((Object)val);
			return val.AddComponent<RemoteBodyDriver>();
		}

		private void LateUpdate()
		{
			//IL_011b: 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_0123: 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_0130: 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)
			//IL_0139: 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_013e: 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_0148: Unknown result type (might be due to invalid IL or missing references)
			//IL_014d: 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_0152: Unknown result type (might be due to invalid IL or missing references)
			//IL_0157: Unknown result type (might be due to invalid IL or missing references)
			//IL_015c: Unknown result type (might be due to invalid IL or missing references)
			//IL_015e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0160: Unknown result type (might be due to invalid IL or missing references)
			//IL_0163: 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_016d: 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_0174: Unknown result type (might be due to invalid IL or missing references)
			//IL_0177: Unknown result type (might be due to invalid IL or missing references)
			//IL_017c: 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_0197: Unknown result type (might be due to invalid IL or missing references)
			//IL_0199: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0217: 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_021c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0221: 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_022b: Unknown result type (might be due to invalid IL or missing references)
			//IL_022e: 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_0370: 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_0375: Unknown result type (might be due to invalid IL or missing references)
			//IL_037a: Unknown result type (might be due to invalid IL or missing references)
			//IL_037f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0391: Unknown result type (might be due to invalid IL or missing references)
			//IL_0393: Unknown result type (might be due to invalid IL or missing references)
			//IL_0396: Unknown result type (might be due to invalid IL or missing references)
			//IL_039b: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a0: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if (!VRConfig.MultiplayerVRSync.Value)
				{
					return;
				}
				_rescanTimer -= Time.unscaledDeltaTime;
				if (_rescanTimer <= 0f)
				{
					_rescanTimer = 1.5f;
					Rescan();
				}
				foreach (KeyValuePair<int, RemotePlayer> player in _players)
				{
					RemotePlayer value = player.Value;
					if (value == null || (Object)(object)value.Root == (Object)null || !VRNetSync.TryGetInterpolatedPose(player.Key, out var pose))
					{
						continue;
					}
					try
					{
						if (((Object)(object)value.Player.Dying != (Object)null && value.Player.Dying.IsDead) || ((Object)(object)value.Player.Other != (Object)null && value.Player.Other.OnBoat) || ((Object)(object)value.Player.Movement != (Object)null && value.Player.Movement.OnBoat))
						{
							continue;
						}
						goto IL_010b;
					}
					catch
					{
						goto IL_010b;
					}
					IL_010b:
					Quaternion val = Quaternion.Euler(0f, pose.BodyYaw, 0f);
					Vector3 bodyPos = pose.BodyPos;
					value.Root.SetPositionAndRotation(bodyPos, val);
					Vector3 val2 = bodyPos + val * pose.RightPos;
					Quaternion val3 = val * pose.RightRot;
					Vector3 val4 = bodyPos + val * pose.LeftPos;
					Quaternion val5 = val * pose.LeftRot;
					if ((Object)(object)value.HandR != (Object)null)
					{
						value.HandR.SetPositionAndRotation(val2, val3);
					}
					if ((Object)(object)value.HandL != (Object)null)
					{
						value.HandL.SetPositionAndRotation(val4, val5);
					}
					try
					{
						Item val6 = (((Object)(object)value.Player.Holding != (Object)null) ? value.Player.Holding.HeldItem : null);
						if (pose.Held && (Object)(object)val6 != (Object)null && (Object)(object)((Component)val6).transform != (Object)null)
						{
							((Component)val6).transform.SetPositionAndRotation(bodyPos + val * pose.HeldPos, val * pose.HeldRot);
							if (!pose.HeldIsTool && (Object)(object)val6.Rig != (Object)null)
							{
								if ((Object)(object)value.PinnedItem != (Object)(object)val6)
								{
									RestorePinned(value);
									value.PinnedItem = val6;
									try
									{
										val6.Rig.isKinematic = true;
									}
									catch
									{
									}
								}
							}
							else if ((Object)(object)value.PinnedItem != (Object)null)
							{
								RestorePinned(value);
							}
						}
						else if ((Object)(object)value.PinnedItem != (Object)null)
						{
							RestorePinned(value);
						}
						if (pose.LaserActive && (Object)(object)val6 != (Object)null && (Object)(object)val6.Weapon != (Object)null && (Object)(object)val6.Weapon.Attachments != (Object)null)
						{
							LaserSight laserSight = val6.Weapon.Attachments._laserSight;
							if ((Object)(object)laserSight != (Object)null && (Object)(object)laserSight._line != (Object)null)
							{
								if (!((Behaviour)laserSight).enabled)
								{
									((Behaviour)laserSight).enabled = true;
								}
								if (!((Renderer)laserSight._line).enabled)
								{
									((Renderer)laserSight._line).enabled = true;
								}
								if (laserSight._line.positionCount < 2)
								{
									laserSight._line.positionCount = 2;
								}
								laserSight._line.SetPosition(0, bodyPos + val * pose.LaserStart);
								laserSight._line.SetPosition(1, bodyPos + val * pose.LaserEnd);
							}
						}
					}
					catch
					{
					}
					if ((Object)(object)value.IkR != (Object)null && (Object)(object)value.IkL != (Object)null)
					{
						value.IkR.Target = value.HandR;
						value.IkL.Target = value.HandL;
						if (!((Behaviour)value.IkR).enabled)
						{
							((Behaviour)value.IkR).enabled = true;
						}
						if (!((Behaviour)value.IkL).enabled)
						{
							((Behaviour)value.IkL).enabled = true;
						}
						value.IkR._enableStretch = false;
						value.IkL._enableStretch = false;
						value.IkR._snapBackStrength = 0f;
						value.IkL._snapBackStrength = 0f;
						value.IkR._iterations = 6;
						value.IkL._iterations = 6;
						PlacePoles(value);
					}
				}
			}
			catch
			{
			}
		}

		private static void RestorePinned(RemotePlayer rp)
		{
			if ((Object)(object)rp.PinnedItem == (Object)null)
			{
				return;
			}
			try
			{
				if ((Object)(object)rp.PinnedItem.Rig != (Object)null && rp.PinnedItem.Rig.isKinematic)
				{
					rp.PinnedItem.Rig.isKinematic = false;
				}
			}
			catch
			{
			}
			rp.PinnedItem = null;
		}

		private void Rescan()
		{
			//IL_018c: 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)
			try
			{
				Player[] array = Object.FindObjectsOfType<Player>(true);
				HashSet<int> hashSet = new HashSet<int>();
				Player[] array2 = array;
				foreach (Player val in array2)
				{
					if ((Object)(object)val == (Object)null || (Object)(object)val == (Object)(object)Player.LocalPlayer)
					{
						continue;
					}
					NetworkObject networkObject = ((NetworkBehaviour)val).NetworkObject;
					if ((Object)(object)networkObject == (Object)null)
					{
						continue;
					}
					int objectId = networkObject.ObjectId;
					hashSet.Add(objectId);
					if (_players.ContainsKey(objectId) || !VRNetSync.TryGetPose(objectId, out var _))
					{
						continue;
					}
					PlayerHands hands = val.Hands;
					if (!((Object)(object)hands == (Object)null))
					{
						Transform root = (((Object)(object)val.Other != (Object)null && (Object)(object)val.Other.Transform != (Object)null) ? val.Other.Transform : val.Transform);
						RemotePlayer remotePlayer = new RemotePlayer
						{
							Player = val,
							Root = root,
							HandR = hands.HandBoneRight,
							HandL = hands.HandBoneLeft,
							IkR = (((Object)(object)val.Arms != (Object)null) ? val.Arms._ikRight : null),
							IkL = (((Object)(object)val.Arms != (Object)null) ? val.Arms._ikLeft : null)
						};
						if (!((Object)(object)remotePlayer.HandR == (Object)null) && !((Object)(object)remotePlayer.HandL == (Object)null) && !((Object)(object)remotePlayer.IkR == (Object)null) && !((Object)(object)remotePlayer.IkL == (Object)null))
						{
							Transform transform = new GameObject("VR Remote Elbow Pole R").transform;
							transform.SetParent(val.Transform, false);
							Transform transform2 = new GameObject("VR Remote Elbow Pole L").transform;
							transform2.SetParent(val.Transform, false);
							remotePlayer.PoleR = transform;
							remotePlayer.PoleL = transform2;
							_players[objectId] = remotePlayer;
						}
					}
				}
				List<int> list = new List<int>();
				foreach (int key in _players.Keys)
				{
					if (!hashSet.Contains(key))
					{
						list.Add(key);
					}
				}
				foreach (int item in list)
				{
					if (_players.TryGetValue(item, out var value))
					{
						RestorePinned(value);
						_players.Remove(item);
					}
				}
			}
			catch
			{
			}
		}

		private static void PlacePoles(RemotePlayer rp)
		{
			//IL_000b: 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)
			//IL_001f: 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_003f: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				Quaternion torso = Quaternion.Euler(0f, rp.Root.eulerAngles.y, 0f);
				PlaceOnePole(rp.IkR, rp.PoleR, torso, left: false);
				PlaceOnePole(rp.IkL, rp.PoleL, torso, left: true);
			}
			catch
			{
			}
		}

		private static void PlaceOnePole(IK ik, Transform pole, Quaternion torso, bool left)
		{
			//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_006c: 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_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: 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_0095: 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_00a1: 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_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: 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_00d5: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)ik == (Object)null || (Object)(object)pole == (Object)null)
			{
				return;
			}
			Transform[] bones = ik._bones;
			if (bones != null && bones.Length >= 3 && !((Object)(object)bones[0] == (Object)null) && !((Object)(object)bones[1] == (Object)null) && !((Object)(object)bones[2] == (Object)null))
			{
				Vector3 position = bones[0].position;
				Vector3 handPos = (((Object)(object)ik.Target != (Object)null) ? ik.Target.position : bones[2].position);
				Quaternion handRot = (((Object)(object)ik.Target != (Object)null) ? ik.Target.rotation : bones[2].rotation);
				float num = Vector3.Distance(bones[0].position, bones[1].position) + Vector3.Distance(bones[1].position, bones[2].position);
				if (!(num < 0.0001f))
				{
					pole.position = ArmRig.ComputeElbowPole(position, handPos, torso, handRot, num, left);
				}
			}
		}
	}
}