using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using HarmonyLib;
using HeinhouserHoloLens;
using Il2CppLiv.Lck;
using Il2CppRUMBLE.Managers;
using Il2CppRUMBLE.Players;
using Il2CppRUMBLE.Players.Subsystems;
using Il2CppRUMBLE.Recording.LCK;
using Il2CppRUMBLE.Recording.LCK.Extensions;
using Il2CppRUMBLE.Utilities;
using MelonLoader;
using MelonLoader.Preferences;
using RumbleModdingAPI.RMAPI;
using UIFramework;
using UIFramework.Models;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: MelonInfo(typeof(Core), "HeinhouserHoloLens", "1.1.10", "UlvakSkillz", null)]
[assembly: MelonGame("Buckethead Entertainment", "RUMBLE")]
[assembly: MelonColor(255, 195, 0, 255)]
[assembly: MelonAuthorColor(255, 195, 0, 255)]
[assembly: VerifyLoaderVersion(0, 7, 2, true)]
[assembly: MelonAdditionalDependencies(new string[] { "UIFramework" })]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = ".NET 6.0")]
[assembly: AssemblyCompany("HeinhouserHoloLens")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+6787c24118053ed3befd023fcfcb913fa618b52b")]
[assembly: AssemblyProduct("HeinhouserHoloLens")]
[assembly: AssemblyTitle("HeinhouserHoloLens")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace HeinhouserHoloLens;

internal static class CameraSettings
{
	internal static string SettingsToString()
	{
		return $"{(Core.isMatchmaking ? "player1 = 0, player2 = 1, " : ((Core.currentScene == "Park") ? $"parkPlayer1 = {Preferences.PrefCamPlayer1.Value}, parkPlayer2 = {Preferences.PrefCamPlayer2.Value}, " : ""))}cameraMoveSpeed = {Preferences.PrefCameraMoveSpeed.Value}, cameraOrbitSpeed = {Preferences.PrefCameraOrbitSpeed.Value}, cameraPositionCorrectionScaler = {Preferences.PrefCamPosCorrection.Value}, CameraDistanceFromMapCenterAllowed = {Preferences.PrefMaxCenterDist.Value}, playerCenterSmoothing = {Preferences.PrefPlayerCenterSmoothing.Value}, cameraPositionIncrease = {Preferences.PrefCamPosIncrease.Value}, cameraPositionFalloff = {Preferences.PrefCamPosFalloff.Value}, cameraPositionBuffer = {Preferences.PrefCamPosBuffer.Value}, allowedHeightScaler = {Preferences.PrefAllowedHeightScaler.Value}";
	}
}
internal class CameraControl
{
	[HarmonyPatch(typeof(LCKTabletUtility), "OnRecordingStarted", new Type[] { typeof(LckResult) })]
	public static class LCKTabletUtilityOnRecordingStartedPatch
	{
		private static void Postfix(LckResult result)
		{
			IsRecording = true;
			UpdateRecordingLens();
		}
	}

	[HarmonyPatch(typeof(LCKTabletUtility), "OnRecordingStopped", new Type[] { typeof(LckResult) })]
	public static class LCKTabletUtilityOnRecordingStoppedPatch
	{
		private static void Postfix(LckResult result)
		{
			IsRecording = false;
			UpdateRecordingLens();
		}
	}

	private static bool cameraIsBeingControlled = false;

	private static GameObject ddolHoloLens = null;

	private static GameObject activeHoloLens = null;

	private static Transform camera = null;

	private static bool IsRecording = false;

	private static bool grabbedMaterial = false;

	private static bool IsActiveHoloLensNormal = true;

	internal static void OnLateInitializeMelon()
	{
		ddolHoloLens = Object.Instantiate<GameObject>(AssetBundles.LoadAssetFromStream<GameObject>(Core.instance, "HeinhouserHoloLens.hololens", "HoloLens"));
		((Object)ddolHoloLens).name = "HoloLens";
		ddolHoloLens.SetActive(false);
		Object.DontDestroyOnLoad((Object)(object)ddolHoloLens);
	}

	internal static void OnSceneWasLoaded()
	{
		cameraIsBeingControlled = false;
	}

	internal static void MapLoaded(string map)
	{
		if (!grabbedMaterial && Core.currentScene == "Gym")
		{
			((Renderer)((Component)ddolHoloLens.transform.GetChild(0).GetChild(3)).GetComponent<MeshRenderer>()).material = ((Renderer)TposePlayer.GetGameObject().GetComponent<MeshRenderer>()).material;
			grabbedMaterial = true;
			if (Preferences.PrefAutoMonitor.Value)
			{
				MelonCoroutines.Start(AutoMonitorStart());
			}
		}
		if (Preferences.PrefEnable.Value && Core.isMatchmaking)
		{
			StartSpectate();
		}
		else if (Preferences.PrefEnable.Value && Preferences.PrefRevertToFps.Value && Core.currentScene == "Gym")
		{
			Singleton<PlayerManager>.instance.localPlayer.Controller.PlayerLIV.LckTablet.lckCameraController.CameraModeChanged((CameraMode)1);
		}
	}

	private static IEnumerator AutoMonitorStart()
	{
		yield return (object)new WaitForSeconds(0.25f);
		LCKCameraController lckCameraController = Singleton<PlayerManager>.instance.localPlayer.Controller.PlayerLIV.LckTablet.lckCameraController;
		lckCameraController.CameraModeChanged((CameraMode)1);
		if (lckCameraController.CurrentCameraOrientation != Preferences.PrefCamMode.Value)
		{
			lckCameraController._orientationButton.RPC_OnPressed();
		}
		lckCameraController.SelfieFOVDoubleButton.ApplySavedData(Preferences.PrefCamFOV.Value);
		Singleton<PlayerManager>.instance.localPlayer.Controller.PlayerLIV.LckTablet.lckDetachedPreview.SwitchPreview(5);
	}

	internal static void Save(bool holoLensEnabledChanged, bool showCameraInGameChanged, bool spectateActiveChanged)
	{
		//IL_0143: 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)
		bool flag = Preferences.IsPrefChanged((MelonPreferences_Entry)(object)Preferences.PrefCamPlayer1) || Preferences.IsPrefChanged((MelonPreferences_Entry)(object)Preferences.PrefCamPlayer2);
		bool flag2 = Preferences.IsPrefChanged((MelonPreferences_Entry)(object)Preferences.PrefCameraMoveSpeed) || Preferences.IsPrefChanged((MelonPreferences_Entry)(object)Preferences.PrefCameraOrbitSpeed) || Preferences.IsPrefChanged((MelonPreferences_Entry)(object)Preferences.PrefCamPosCorrection) || Preferences.IsPrefChanged((MelonPreferences_Entry)(object)Preferences.PrefMaxCenterDist) || Preferences.IsPrefChanged((MelonPreferences_Entry)(object)Preferences.PrefPlayerCenterSmoothing) || Preferences.IsPrefChanged((MelonPreferences_Entry)(object)Preferences.PrefCamPosIncrease) || Preferences.IsPrefChanged((MelonPreferences_Entry)(object)Preferences.PrefCamPosFalloff) || Preferences.IsPrefChanged((MelonPreferences_Entry)(object)Preferences.PrefCamPosBuffer) || Preferences.IsPrefChanged((MelonPreferences_Entry)(object)Preferences.PrefAllowedHeightScaler);
		if (Preferences.IsPrefChanged((MelonPreferences_Entry)(object)Preferences.PrefAutoMonitor))
		{
			Singleton<PlayerManager>.instance.localPlayer.Controller.PlayerLIV.LckTablet.lckDetachedPreview.SwitchPreview(Preferences.PrefAutoMonitor.Value ? 5 : 0);
		}
		if (Preferences.IsPrefChanged((MelonPreferences_Entry)(object)Preferences.PrefCamFOV))
		{
			Singleton<PlayerManager>.instance.localPlayer.Controller.PlayerLIV.LckTablet.lckCameraController.SelfieFOVDoubleButton.ApplySavedData(Preferences.PrefCamFOV.Value);
		}
		if (Preferences.IsPrefChanged((MelonPreferences_Entry)(object)Preferences.PrefCamMode))
		{
			LCKCameraController lckCameraController = Singleton<PlayerManager>.instance.localPlayer.Controller.PlayerLIV.LckTablet.lckCameraController;
			if (lckCameraController.CurrentCameraOrientation != Preferences.PrefCamMode.Value)
			{
				lckCameraController._orientationButton.RPC_OnPressed();
			}
		}
		if (flag2)
		{
			if (Preferences.PrefEnable.Value && Core.isMatchmaking && cameraIsBeingControlled)
			{
				StartSpectate();
			}
			else if (Preferences.PrefEnable.Value && cameraIsBeingControlled && Core.currentScene.Contains("Park"))
			{
				StartSpectate(Preferences.PrefCamPlayer1.Value, Preferences.PrefCamPlayer2.Value);
			}
			return;
		}
		if (Core.isMatchmaking)
		{
			if (Preferences.PrefEnable.Value && showCameraInGameChanged)
			{
				if (Preferences.PrefShowInGame.Value && (Object)(object)activeHoloLens == (Object)null)
				{
					CreateHoloLens();
				}
				else if (!Preferences.PrefShowInGame.Value && (Object)(object)activeHoloLens != (Object)null)
				{
					Object.Destroy((Object)(object)activeHoloLens);
					activeHoloLens = null;
				}
			}
			if (holoLensEnabledChanged)
			{
				if (Preferences.PrefEnable.Value)
				{
					StartSpectate();
				}
				else
				{
					cameraIsBeingControlled = false;
				}
			}
			return;
		}
		if (flag && Preferences.PrefCamSpectate.Value && Preferences.PrefEnable.Value)
		{
			StartSpectate(Preferences.PrefCamPlayer1.Value, Preferences.PrefCamPlayer2.Value);
		}
		if (spectateActiveChanged)
		{
			if (Preferences.PrefCamSpectate.Value)
			{
				StartSpectate(Preferences.PrefCamPlayer1.Value, Preferences.PrefCamPlayer2.Value);
			}
			else
			{
				cameraIsBeingControlled = false;
			}
		}
	}

	private static void UpdateRecordingLens()
	{
		if (IsActiveHoloLensNormal && (Object)(object)activeHoloLens != (Object)null)
		{
			((Component)activeHoloLens.transform.GetChild(0).GetChild(0)).gameObject.SetActive(!IsRecording);
			((Component)activeHoloLens.transform.GetChild(0).GetChild(1)).gameObject.SetActive(IsRecording);
		}
	}

	private static void CreateHoloLens()
	{
		//IL_0064: 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)
		if ((Object)(object)activeHoloLens == (Object)null)
		{
			activeHoloLens = Object.Instantiate<GameObject>(ddolHoloLens);
			((Object)activeHoloLens).name = "HoloLens";
			activeHoloLens.SetActive(true);
			activeHoloLens.transform.SetParent(camera.GetChild(0));
			activeHoloLens.transform.localPosition = Vector3.zero;
			activeHoloLens.transform.localRotation = Quaternion.identity;
			if (Core.random.Next(0, 100) < Preferences.PrefHeadChance.Value)
			{
				IsActiveHoloLensNormal = false;
				((Component)activeHoloLens.transform.GetChild(0).GetChild(0)).gameObject.SetActive(false);
				((Component)activeHoloLens.transform.GetChild(0).GetChild(1)).gameObject.SetActive(false);
				((Component)activeHoloLens.transform.GetChild(0).GetChild(2)).gameObject.SetActive(false);
				((Component)activeHoloLens.transform.GetChild(0).GetChild(3)).gameObject.SetActive(true);
			}
			else
			{
				UpdateRecordingLens();
			}
		}
	}

	private static void StartSpectate(int player1 = 0, int player2 = 1)
	{
		MelonCoroutines.Start(StartSpectateCoroutine(player1, player2));
	}

	private static IEnumerator StartSpectateCoroutine(int player1 = 0, int player2 = 1)
	{
		Singleton<PlayerManager>.instance.localPlayer.Controller.PlayerLIV.ShowTablet();
		yield return (object)new WaitForSeconds(0.25f);
		MelonCoroutines.Start(RunSpectateCamera(player1, player2));
		yield return (object)new WaitForSeconds(0.5f);
		LCKCameraController lckCameraController = Singleton<PlayerManager>.instance.localPlayer.Controller.PlayerLIV.LckTablet.lckCameraController;
		while ((Object)(object)lckCameraController == (Object)null)
		{
			yield return (object)new WaitForSeconds(0.1f);
			lckCameraController = Singleton<PlayerManager>.instance.localPlayer.Controller.PlayerLIV.LckTablet.lckCameraController;
		}
		lckCameraController.CameraModeChanged((CameraMode)0);
		lckCameraController.SelfieFOVDoubleButton.ApplySavedData(Preferences.PrefCamFOV.Value);
		lckCameraController.SelfieSmoothingDoubleButton.ApplySavedData(0);
		if (lckCameraController.CurrentCameraOrientation != Preferences.PrefCamMode.Value)
		{
			lckCameraController._orientationButton.RPC_OnPressed();
		}
		yield return (object)new WaitForSeconds(0.25f);
		Singleton<PlayerManager>.instance.localPlayer.Controller.PlayerLIV.HideTablet();
	}

	private static IEnumerator RunSpectateCamera(int player1 = 0, int player2 = 1)
	{
		Melon<Core>.Logger.Msg("Playing Spectate Mode: " + CameraSettings.SettingsToString());
		if (cameraIsBeingControlled)
		{
			cameraIsBeingControlled = false;
			yield return (object)new WaitForFixedUpdate();
			yield return (object)new WaitForFixedUpdate();
		}
		cameraIsBeingControlled = true;
		Transform selectedPlayer1 = ((Singleton<PlayerManager>.instance.AllPlayers.Count > player1) ? ((Component)Singleton<PlayerManager>.instance.AllPlayers[player1].Controller).transform.FindChild("Visuals/Skelington/Bone_Pelvis/Bone_Spine_A/Bone_Chest") : ((Component)Singleton<PlayerManager>.instance.localPlayer.Controller).transform.FindChild("Visuals/Skelington/Bone_Pelvis/Bone_Spine_A/Bone_Chest"));
		Transform selectedPlayer2 = ((Singleton<PlayerManager>.instance.AllPlayers.Count > player2) ? ((Component)Singleton<PlayerManager>.instance.AllPlayers[player2].Controller).transform.FindChild("Visuals/Skelington/Bone_Pelvis/Bone_Spine_A/Bone_Chest") : ((Component)Singleton<PlayerManager>.instance.localPlayer.Controller).transform.FindChild("Visuals/Skelington/Bone_Pelvis/Bone_Spine_A/Bone_Chest"));
		camera = ((Component)Singleton<PlayerManager>.instance.localPlayer.Controller.PlayerLIV.LckTablet.selfieCamera).gameObject.transform.parent;
		Transform cameraRotationControl = new GameObject("SmoothCameraControl").transform;
		Transform originalParent = ((Component)Singleton<PlayerManager>.instance.localPlayer.Controller.PlayerLIV.LckTablet.selfieCamera).gameObject.transform.parent.parent;
		Vector3 originalLocalPos = camera.localPosition;
		Quaternion originalLocalRot = camera.localRotation;
		float localDistance = Vector3.Distance(camera.position, selectedPlayer1.position);
		float remoteDistance = Vector3.Distance(camera.position, selectedPlayer2.position);
		float playerCenterLerpSpot = remoteDistance / (localDistance + remoteDistance);
		Vector3 smoothedPlayersCenter = Vector3.Lerp(selectedPlayer2.position, selectedPlayer1.position, playerCenterLerpSpot);
		camera.SetParent((Transform)null);
		bool isOrbitingRight = true;
		if (Preferences.PrefShowInGame.Value)
		{
			CreateHoloLens();
		}
		cameraRotationControl.position = camera.position;
		cameraRotationControl.rotation = camera.rotation;
		while (cameraIsBeingControlled && (Object)(object)selectedPlayer1 != (Object)null && (Object)(object)selectedPlayer2 != (Object)null && (Object)(object)camera != (Object)null && (Object)(object)cameraRotationControl != (Object)null)
		{
			localDistance = Vector3.Distance(camera.position, selectedPlayer1.position);
			remoteDistance = Vector3.Distance(camera.position, selectedPlayer2.position);
			playerCenterLerpSpot = remoteDistance / (localDistance + remoteDistance);
			Vector3 rawPlayersCenter = Vector3.Lerp(selectedPlayer2.position, selectedPlayer1.position, playerCenterLerpSpot);
			smoothedPlayersCenter = Vector3.Lerp(smoothedPlayersCenter, rawPlayersCenter, Preferences.PrefPlayerCenterSmoothing.Value * Time.fixedDeltaTime);
			float distanceToPlayersCenter = Vector3.Distance(smoothedPlayersCenter, camera.position);
			float baseDistance = Vector3.Distance(selectedPlayer1.position, selectedPlayer2.position) / 2f;
			float scaledIncrease = Preferences.PrefCamPosIncrease.Value / (1f + baseDistance * Preferences.PrefCamPosFalloff.Value);
			float idealCameraDistance = baseDistance + scaledIncrease;
			float allowedHeight = Math.Min(10f, Vector3.Distance(selectedPlayer1.position, selectedPlayer2.position) / Preferences.PrefAllowedHeightScaler.Value);
			if (Mathf.Abs(distanceToPlayersCenter - idealCameraDistance) > Preferences.PrefCamPosBuffer.Value)
			{
				Vector3 val = cameraRotationControl.position - smoothedPlayersCenter;
				Vector3 dirFromCenter = ((Vector3)(ref val)).normalized;
				cameraRotationControl.position = Vector3.Lerp(cameraRotationControl.position, smoothedPlayersCenter + dirFromCenter * idealCameraDistance, Time.fixedDeltaTime * Preferences.PrefCameraMoveSpeed.Value);
			}
			float clampedY = Mathf.Clamp(cameraRotationControl.position.y, smoothedPlayersCenter.y, smoothedPlayersCenter.y + allowedHeight);
			Vector3 clampedYVector = new Vector3(cameraRotationControl.position.x, clampedY, cameraRotationControl.position.z);
			cameraRotationControl.position = Vector3.Lerp(cameraRotationControl.position, clampedYVector, Time.fixedDeltaTime * Preferences.PrefCameraMoveSpeed.Value);
			if (Core.isMatchmaking)
			{
				float distanceToCenter = Vector2.Distance(Vector2.zero, new Vector2(cameraRotationControl.position.x, cameraRotationControl.position.z));
				while (Vector2.Distance(Vector2.zero, new Vector2(smoothedPlayersCenter.x, smoothedPlayersCenter.z)) < Preferences.PrefMaxCenterDist.Value && distanceToCenter > Preferences.PrefMaxCenterDist.Value)
				{
					cameraRotationControl.position += cameraRotationControl.forward * Preferences.PrefCamPosCorrection.Value;
					cameraRotationControl.LookAt(smoothedPlayersCenter);
					distanceToCenter = Vector2.Distance(Vector2.zero, new Vector2(cameraRotationControl.position.x, cameraRotationControl.position.z));
				}
			}
			if (Vector3.Distance(camera.position, cameraRotationControl.position) < Preferences.PrefCamPosBuffer.Value / Preferences.PrefMaxCenterDist.Value)
			{
				Vector3 movementAmount = (float)(isOrbitingRight ? 1 : (-1)) * cameraRotationControl.right * Preferences.PrefCamPosCorrection.Value;
				Vector3 desiredOrbitPos = cameraRotationControl.position - movementAmount;
				if (!Core.isMatchmaking || Vector2.Distance(Vector2.zero, new Vector2(desiredOrbitPos.x, desiredOrbitPos.z)) <= Preferences.PrefMaxCenterDist.Value)
				{
					cameraRotationControl.RotateAround(smoothedPlayersCenter, Vector3.up, (isOrbitingRight ? 1f : (-1f)) * Preferences.PrefCameraOrbitSpeed.Value * Time.fixedDeltaTime);
				}
				else
				{
					isOrbitingRight = !isOrbitingRight;
				}
			}
			cameraRotationControl.LookAt(smoothedPlayersCenter);
			camera.position = cameraRotationControl.position;
			camera.rotation = cameraRotationControl.rotation;
			yield return (object)new WaitForFixedUpdate();
		}
		IsActiveHoloLensNormal = true;
		if ((Object)(object)activeHoloLens != (Object)null)
		{
			Object.Destroy((Object)(object)activeHoloLens);
		}
		if ((Object)(object)cameraRotationControl != (Object)null && (Object)(object)((Component)cameraRotationControl).gameObject != (Object)null)
		{
			Object.Destroy((Object)(object)((Component)cameraRotationControl).gameObject);
		}
		if ((Object)(object)camera != (Object)null && (Object)(object)originalParent != (Object)null)
		{
			camera.SetParent(originalParent);
			camera.localPosition = originalLocalPos;
			camera.localRotation = originalLocalRot;
		}
		int num;
		if (Preferences.PrefRevertToFps.Value)
		{
			Player localPlayer = Singleton<PlayerManager>.instance.localPlayer;
			object obj;
			if (localPlayer == null)
			{
				obj = null;
			}
			else
			{
				PlayerController controller = localPlayer.Controller;
				if (controller == null)
				{
					obj = null;
				}
				else
				{
					PlayerLIV playerLIV = controller.PlayerLIV;
					if (playerLIV == null)
					{
						obj = null;
					}
					else
					{
						LCKTabletUtility lckTablet = playerLIV.LckTablet;
						obj = ((lckTablet != null) ? lckTablet.lckCameraController : null);
					}
				}
			}
			num = (((Object)obj != (Object)null) ? 1 : 0);
		}
		else
		{
			num = 0;
		}
		if (num != 0)
		{
			Singleton<PlayerManager>.instance.localPlayer.Controller.PlayerLIV.LckTablet.lckCameraController.CameraModeChanged((CameraMode)1);
		}
	}
}
public static class BuildInfo
{
	public const string ModName = "HeinhouserHoloLens";

	public const string ModVersion = "1.1.10";

	public const string Author = "UlvakSkillz";
}
public class Core : MelonMod
{
	internal static MelonMod instance;

	internal static string currentScene = "Loader";

	internal static bool isMatchmaking = false;

	internal static Random random = new Random();

	public override void OnInitializeMelon()
	{
		Preferences.InitPrefs();
		((ModModelBase)UI.RegisterMelon((MelonBase)(object)this, (MelonPreferences_Category[])(object)new MelonPreferences_Category[4]
		{
			Preferences.HoloLensCategory,
			Preferences.CameraSpectateCategory,
			Preferences.CameraMovementCategory,
			Preferences.CameraPositionCategory
		})).OnModSaved += Save;
	}

	public override void OnSceneWasLoaded(int buildIndex, string sceneName)
	{
		currentScene = sceneName;
		string text = currentScene;
		bool flag = ((text == "Map0" || text == "Map1") ? true : false);
		isMatchmaking = flag;
		Preferences.PrefCamSpectate.Value = false;
		CameraControl.OnSceneWasLoaded();
	}

	public override void OnLateInitializeMelon()
	{
		instance = (MelonMod)(object)this;
		CameraControl.OnLateInitializeMelon();
		Actions.onMapInitialized += CameraControl.MapLoaded;
	}

	private void Save()
	{
		CameraControl.Save(Preferences.IsPrefChanged((MelonPreferences_Entry)(object)Preferences.PrefEnable), Preferences.IsPrefChanged((MelonPreferences_Entry)(object)Preferences.PrefShowInGame), Preferences.IsPrefChanged((MelonPreferences_Entry)(object)Preferences.PrefCamSpectate));
		Preferences.StoreLastSavedPrefs();
	}
}
public class Preferences
{
	private const string CONFIG_FILE = "config.cfg";

	private const string USER_DATA = "UserData/HeinhouserHoloLens/";

	internal static Dictionary<MelonPreferences_Entry, object> LastSavedValues = new Dictionary<MelonPreferences_Entry, object>();

	internal static MelonPreferences_Category HoloLensCategory;

	internal static MelonPreferences_Entry<bool> PrefEnable;

	internal static MelonPreferences_Entry<bool> PrefShowInGame;

	internal static MelonPreferences_Entry<bool> PrefRevertToFps;

	internal static MelonPreferences_Entry<bool> PrefAutoMonitor;

	internal static MelonPreferences_Entry<int> PrefHeadChance;

	internal static MelonPreferences_Category CameraSpectateCategory;

	internal static MelonPreferences_Entry<int> PrefCamFOV;

	internal static MelonPreferences_Entry<LckCameraOrientation> PrefCamMode;

	internal static MelonPreferences_Entry<bool> PrefCamSpectate;

	internal static MelonPreferences_Entry<int> PrefCamPlayer1;

	internal static MelonPreferences_Entry<int> PrefCamPlayer2;

	internal static MelonPreferences_Category CameraMovementCategory;

	internal static MelonPreferences_Entry<float> PrefCameraMoveSpeed;

	internal static MelonPreferences_Entry<float> PrefCameraOrbitSpeed;

	internal static MelonPreferences_Entry<float> PrefCamPosCorrection;

	internal static MelonPreferences_Entry<float> PrefMaxCenterDist;

	internal static MelonPreferences_Category CameraPositionCategory;

	internal static MelonPreferences_Entry<float> PrefPlayerCenterSmoothing;

	internal static MelonPreferences_Entry<float> PrefCamPosIncrease;

	internal static MelonPreferences_Entry<float> PrefCamPosFalloff;

	internal static MelonPreferences_Entry<float> PrefCamPosBuffer;

	internal static MelonPreferences_Entry<float> PrefAllowedHeightScaler;

	internal static void InitPrefs()
	{
		if (!Directory.Exists("UserData/HeinhouserHoloLens/"))
		{
			Directory.CreateDirectory("UserData/HeinhouserHoloLens/");
		}
		HoloLensCategory = MelonPreferences.CreateCategory("HoloLens", "Settings");
		HoloLensCategory.SetFilePath(Path.Combine("UserData/HeinhouserHoloLens/", "config.cfg"));
		PrefEnable = HoloLensCategory.CreateEntry<bool>("EnableHoloLens", true, "Enable Holo Lens", "Toggles HoloLens Camera On/Off", false, false, (ValueValidator)null, (string)null);
		PrefShowInGame = HoloLensCategory.CreateEntry<bool>("ShowInGame", true, "Show HoloLens in Game", "Toggles Camera Visuals On/Off", false, false, (ValueValidator)null, (string)null);
		PrefRevertToFps = HoloLensCategory.CreateEntry<bool>("RevertToFps", true, "Revert To 1st Person", "Reverts to 1st Person View whenever Entering the Gym or Spectating Stops", false, false, (ValueValidator)null, (string)null);
		PrefAutoMonitor = HoloLensCategory.CreateEntry<bool>("AutoMonitor", true, "Auto Monitor", "Automatically Applies the RockCam on the Monitor", false, false, (ValueValidator)null, (string)null);
		PrefHeadChance = HoloLensCategory.CreateEntry<int>("Head Camera Chance", 1, "Head Camera Chance Percent", "Changes the % chance to replace the HoloLens with a Player Head", false, false, (ValueValidator)(object)new ValueRange<int>(0, int.MaxValue), (string)null);
		CameraSpectateCategory = MelonPreferences.CreateCategory("HoloLensCamera", "Camera Settings");
		CameraSpectateCategory.SetFilePath(Path.Combine("UserData/HeinhouserHoloLens/", "config.cfg"));
		PrefCamFOV = CameraSpectateCategory.CreateEntry<int>("CamFOV", 90, "Camera FOV", "Sets the Camera FOV for HoloLens", false, false, (ValueValidator)(object)new ValueRange<int>(0, 360), (string)null);
		PrefCamMode = CameraSpectateCategory.CreateEntry<LckCameraOrientation>("CamMode", (LckCameraOrientation)1, "Camera Mode", "Sets the Camera Mode for HoloLens", false, false, (ValueValidator)(object)new ValueRange<LckCameraOrientation>((LckCameraOrientation)0, (LckCameraOrientation)1), (string)null);
		PrefCamSpectate = CameraSpectateCategory.CreateEntry<bool>("CamSpectate", false, "Camera Spectate Activate", "Toggles On/Off Spectating in non-Matchmaking Maps", false, false, (ValueValidator)null, (string)null);
		PrefCamPlayer1 = CameraSpectateCategory.CreateEntry<int>("CamPlayer1", 0, "Camera Player 1", "Selects what Player to Spectate as Player 1 (0 = You, 1 = Oldest Remote Player, 2 = 2nd Oldest Remote Player, etc)" + Environment.NewLine + "Defaults to Local Player if invalid", false, false, (ValueValidator)(object)new ValueRange<int>(0, int.MaxValue), (string)null);
		PrefCamPlayer2 = CameraSpectateCategory.CreateEntry<int>("CamPlayer2", 1, "Camera Player 2", "Selects what Player to Spectate as Player 2 (0 = You, 1 = Oldest Remote Player, 2 = 2nd Oldest Remote Player, etc)" + Environment.NewLine + "Defaults to Local Player if invalid", false, false, (ValueValidator)(object)new ValueRange<int>(0, int.MaxValue), (string)null);
		CameraMovementCategory = MelonPreferences.CreateCategory("HoloLensCameraMovement", "Camera Movement");
		CameraMovementCategory.SetFilePath(Path.Combine("UserData/HeinhouserHoloLens/", "config.cfg"));
		PrefCameraMoveSpeed = CameraMovementCategory.CreateEntry<float>("CameraMoveSpeed", 6.5f, "Move Speed", "Controls how fast the Camera moves Forwards/Backwards and Up/Down" + Environment.NewLine + "Default: 6.5", false, false, (ValueValidator)(object)new ValueRange<float>(0f, float.MaxValue), (string)null);
		PrefCameraOrbitSpeed = CameraMovementCategory.CreateEntry<float>("CameraOrbitSpeed", 6f, "Orbit Speed", "Controls how fast the Camera Orbits around the Viewing Point" + Environment.NewLine + "Default: 6", false, false, (ValueValidator)(object)new ValueRange<float>(0f, float.MaxValue), (string)null);
		PrefCamPosCorrection = CameraMovementCategory.CreateEntry<float>("CamPosCorrection", 0.01f, "Position Correction Scaler", "Controls how fast the Camera moves when Orbiting and getting away from Walls" + Environment.NewLine + "Default: 0.01", false, false, (ValueValidator)(object)new ValueRange<float>(0f, float.MaxValue), (string)null);
		PrefMaxCenterDist = CameraMovementCategory.CreateEntry<float>("MaxCenterDist", 10.25f, "Max Center Distance", "Controls how far the Camera can move from the Center of the Matchmaking Map" + Environment.NewLine + "Default: 10.25", false, false, (ValueValidator)(object)new ValueRange<float>(0f, float.MaxValue), (string)null);
		CameraPositionCategory = MelonPreferences.CreateCategory("HoloLensCameraPosition", "Camera Position");
		CameraPositionCategory.SetFilePath(Path.Combine("UserData/HeinhouserHoloLens/", "config.cfg"));
		PrefPlayerCenterSmoothing = CameraPositionCategory.CreateEntry<float>("PlayerCenterSmoothing", 6f, "Player Center Smoothing", "Controls how Smooth the Look at Center of the Players moves" + Environment.NewLine + "Default: 6", false, false, (ValueValidator)(object)new ValueRange<float>(0f, float.MaxValue), (string)null);
		PrefCamPosIncrease = CameraPositionCategory.CreateEntry<float>("CamPosIncrease", 2f, "Camera Position Increase", "Controls how far away the Camera is from the Player's Center Point" + Environment.NewLine + "Default: 2", false, false, (ValueValidator)(object)new ValueRange<float>(0f, float.MaxValue), (string)null);
		PrefCamPosFalloff = CameraPositionCategory.CreateEntry<float>("CamPosFalloff", 0.25f, "Camera Position Falloff", "Controls how fast the Camera Position Increase amount falls off" + Environment.NewLine + "Default: 0.25", false, false, (ValueValidator)(object)new ValueRange<float>(0f, float.MaxValue), (string)null);
		PrefCamPosBuffer = CameraPositionCategory.CreateEntry<float>("CamPosBuffer", 0.1f, "Camera Position Buffer", "Determines if the Camera needs to move (small but not 0 is best)" + Environment.NewLine + "Default: 0.1", false, false, (ValueValidator)(object)new ValueRange<float>(0f, float.MaxValue), (string)null);
		PrefAllowedHeightScaler = CameraPositionCategory.CreateEntry<float>("AllowedHeightScaler", 1.5f, "Allowed Height Scaler", "Scaled the Allowed Height of the Camera in comparison to the Player's Center Point Height (smaller = higher, bigger = lower)" + Environment.NewLine + "Default: 1.5", false, false, (ValueValidator)(object)new ValueRange<float>(0f, float.MaxValue), (string)null);
		((MelonPreferences_Entry)PrefCamSpectate).ResetToDefault();
		StoreLastSavedPrefs();
	}

	internal static void StoreLastSavedPrefs()
	{
		List<MelonPreferences_Entry> list = new List<MelonPreferences_Entry>();
		list.AddRange(HoloLensCategory.Entries);
		list.AddRange(CameraSpectateCategory.Entries);
		list.AddRange(CameraMovementCategory.Entries);
		list.AddRange(CameraPositionCategory.Entries);
		foreach (MelonPreferences_Entry item in list)
		{
			LastSavedValues[item] = item.BoxedValue;
		}
	}

	public static bool AnyPrefsChanged()
	{
		foreach (KeyValuePair<MelonPreferences_Entry, object> lastSavedValue in LastSavedValues)
		{
			if (!lastSavedValue.Key.BoxedValue.Equals(lastSavedValue.Value))
			{
				return true;
			}
		}
		return false;
	}

	public static bool IsPrefChanged(MelonPreferences_Entry entry)
	{
		if (LastSavedValues.TryGetValue(entry, out var value))
		{
			return !entry.BoxedValue.Equals(value);
		}
		return false;
	}
}