using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using MelonLoader;
using MelonLoader.Preferences;
using ModThatIsNotMod;
using ModThatIsNotMod.BoneMenu;
using StressLevelZero.Interaction;
using StressLevelZero.Rig;
using TeleportMovement;
using UnhollowerBaseLib;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: MelonInfo(typeof(Main), "Teleport Locomotion", "1.0.0", "ffba", null)]
[assembly: MelonGame("Stress Level Zero", "BONEWORKS")]
[assembly: AssemblyTitle("teleportlocomotion")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("HP")]
[assembly: AssemblyProduct("teleportlocomotion")]
[assembly: AssemblyCopyright("Copyright © HP 2026")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("924dab28-0e64-4baa-81a5-dd33c15f7bbd")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace TeleportMovement;

public class Main : MelonMod
{
	[CompilerGenerated]
	private sealed class <TeleportSequence>d__33 : IEnumerator<object>, IDisposable, IEnumerator
	{
		private int <>1__state;

		private object <>2__current;

		public Transform physicsRig;

		public Rigidbody pelvis;

		public Vector3 targetPos;

		public Main <>4__this;

		private Rigidbody[] <allRigidbodies>5__2;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <TeleportSequence>d__33(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<allRigidbodies>5__2 = null;
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			//IL_007b: 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_00e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			int num = <>1__state;
			Main main = <>4__this;
			switch (num)
			{
			default:
				return false;
			case 0:
			{
				<>1__state = -1;
				<allRigidbodies>5__2 = Il2CppArrayBase<Rigidbody>.op_Implicit(((Component)physicsRig).GetComponentsInChildren<Rigidbody>());
				Rigidbody[] array = <allRigidbodies>5__2;
				for (int i = 0; i < array.Length; i++)
				{
					array[i].isKinematic = true;
				}
				<>2__current = null;
				<>1__state = 1;
				return true;
			}
			case 1:
				<>1__state = -1;
				pelvis.position = targetPos;
				pelvis.velocity = Vector3.zero;
				<>2__current = null;
				<>1__state = 2;
				return true;
			case 2:
			{
				<>1__state = -1;
				Rigidbody[] array = <allRigidbodies>5__2;
				for (int i = 0; i < array.Length; i++)
				{
					array[i].isKinematic = false;
				}
				if (main.useContinuousCorrection)
				{
					main.isCorrecting = true;
					main.correctionTimer = 0f;
					main.targetCorrectionPos = targetPos;
					main.pelvisToCorrect = pelvis;
				}
				else
				{
					main.globalCooldownTimer = main.prefCooldown.Value;
				}
				return false;
			}
			}
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	public static Main Instance;

	private MelonPreferences_Category prefCategory;

	public MelonPreferences_Entry<float> prefMaxDistance;

	public MelonPreferences_Entry<float> prefCooldown;

	public MelonPreferences_Entry<bool> prefDisableMovement;

	public MelonPreferences_Entry<float> prefMaxSlope;

	private LineRenderer lineRenderer;

	private GameObject lineObject;

	private GameObject targetMarker;

	private bool isAiming;

	private Vector3 teleportTarget;

	private bool validTarget;

	private int arcSegments = 30;

	private float arcVelocity = 8f;

	private float arcGravity = 9.81f;

	private Hand aimingHand;

	private float globalCooldownTimer;

	private bool useContinuousCorrection = true;

	private bool isCorrecting;

	private float correctionTimer;

	private float correctionDuration = 1.5f;

	private Vector3 targetCorrectionPos;

	private Rigidbody pelvisToCorrect;

	private const float _BaseAcceleration = 7f;

	private const float _BaseMaxVel = 2f;

	public override void OnApplicationStart()
	{
		//IL_009b: 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_00e2: 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_014f: Unknown result type (might be due to invalid IL or missing references)
		Instance = this;
		prefCategory = MelonPreferences.CreateCategory("TeleportMovement");
		prefMaxDistance = prefCategory.CreateEntry<float>("MaxDistance", 4.5f, (string)null, (string)null, false, false, (ValueValidator)null, (string)null);
		prefCooldown = prefCategory.CreateEntry<float>("TeleportCooldown", 2.5f, (string)null, (string)null, false, false, (ValueValidator)null, (string)null);
		prefDisableMovement = prefCategory.CreateEntry<bool>("DisableNormalMovement", true, (string)null, (string)null, false, false, (ValueValidator)null, (string)null);
		prefMaxSlope = prefCategory.CreateEntry<float>("MaxSlopeAngle", 80f, (string)null, (string)null, false, false, (ValueValidator)null, (string)null);
		MenuCategory obj = MenuManager.CreateCategory("Teleport Locomotion", Color.cyan);
		obj.CreateFloatElement("Max Distance", Color.white, prefMaxDistance.Value, (Action<float>)delegate(float v)
		{
			prefMaxDistance.Value = v;
			prefCategory.SaveToFile(true);
		}, 0.5f, 1f, 20f, true);
		obj.CreateFloatElement("Cooldown (Sec)", Color.yellow, prefCooldown.Value, (Action<float>)delegate(float v)
		{
			prefCooldown.Value = v;
			prefCategory.SaveToFile(true);
		}, 0.1f, 0f, 10f, true);
		obj.CreateFloatElement("Max Slope Angle", Color.green, prefMaxSlope.Value, (Action<float>)delegate(float v)
		{
			prefMaxSlope.Value = v;
			prefCategory.SaveToFile(true);
		}, 5f, 0f, 90f, true);
		obj.CreateBoolElement("Disable Normal Movement", Color.red, prefDisableMovement.Value, (Action<bool>)delegate(bool v)
		{
			prefDisableMovement.Value = v;
			prefCategory.SaveToFile(true);
			UpdateMovementSpeed(v);
		});
	}

	public override void OnUpdate()
	{
		//IL_008e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0094: Unknown result type (might be due to invalid IL or missing references)
		//IL_00df: 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)
		if ((Object)(object)Player.GetRigManager() == (Object)null)
		{
			return;
		}
		UpdateMovementSpeed(prefDisableMovement.Value);
		if (globalCooldownTimer > 0f)
		{
			globalCooldownTimer -= Time.deltaTime;
			return;
		}
		if ((Object)(object)lineObject == (Object)null || (Object)(object)targetMarker == (Object)null)
		{
			CreateTeleportVisuals();
		}
		if (isCorrecting && useContinuousCorrection && (Object)(object)pelvisToCorrect != (Object)null)
		{
			if (Vector3.Distance(pelvisToCorrect.position, targetCorrectionPos) <= 0.5f)
			{
				isCorrecting = false;
				pelvisToCorrect = null;
				globalCooldownTimer = prefCooldown.Value;
			}
			else
			{
				correctionTimer += Time.deltaTime;
				pelvisToCorrect.position = targetCorrectionPos;
				pelvisToCorrect.velocity = Vector3.zero;
				if (correctionTimer >= correctionDuration)
				{
					isCorrecting = false;
					pelvisToCorrect = null;
					globalCooldownTimer = prefCooldown.Value;
				}
			}
		}
		Controller rightController = Player.rightController;
		bool flag = rightController != null && rightController.GetThumbStick();
		Controller leftController = Player.leftController;
		bool flag2 = leftController != null && leftController.GetThumbStick();
		if (isAiming)
		{
			if (((Object)(object)aimingHand == (Object)(object)Player.rightHand) ? flag : flag2)
			{
				UpdateTeleportArc();
				return;
			}
			ExecuteTeleport();
			isAiming = false;
			aimingHand = null;
			HideTeleportArc();
		}
		else if (flag)
		{
			isAiming = true;
			aimingHand = Player.rightHand;
		}
		else if (flag2)
		{
			isAiming = true;
			aimingHand = Player.leftHand;
		}
	}

	private void UpdateMovementSpeed(bool disable)
	{
		GameObject rigManager = Player.GetRigManager();
		RigManager val = ((rigManager != null) ? rigManager.GetComponent<RigManager>() : null);
		if ((Object)(object)val != (Object)null)
		{
			val.ControllerRig.maxAcceleration = (disable ? 0f : 7f);
			val.ControllerRig.maxVelocity = (disable ? 0f : 2f);
		}
	}

	private void CreateTeleportVisuals()
	{
		//IL_0006: Unknown result type (might be due to invalid IL or missing references)
		//IL_0010: Expected O, but got Unknown
		//IL_0031: Unknown result type (might be due to invalid IL or missing references)
		//IL_003b: Expected O, but got Unknown
		//IL_0041: 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_00af: 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_00d8: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e2: Expected O, but got Unknown
		lineObject = new GameObject("TeleportArc");
		lineRenderer = lineObject.AddComponent<LineRenderer>();
		((Renderer)lineRenderer).material = new Material(Shader.Find("Sprites/Default"));
		lineRenderer.startColor = Color.cyan;
		lineRenderer.endColor = Color.blue;
		lineRenderer.startWidth = 0.05f;
		lineRenderer.endWidth = 0.05f;
		lineRenderer.positionCount = arcSegments;
		((Renderer)lineRenderer).enabled = false;
		targetMarker = GameObject.CreatePrimitive((PrimitiveType)0);
		targetMarker.transform.localScale = Vector3.one * 0.3f;
		((Renderer)targetMarker.GetComponent<MeshRenderer>()).material = new Material(Shader.Find("Sprites/Default"));
		Object.Destroy((Object)(object)targetMarker.GetComponent<SphereCollider>());
		targetMarker.SetActive(false);
	}

	private void UpdateTeleportArc()
	{
		//IL_0026: Unknown result type (might be due to invalid IL or missing references)
		//IL_0036: Unknown result type (might be due to invalid IL or missing references)
		//IL_003b: Unknown result type (might be due to invalid IL or missing references)
		//IL_003c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0042: 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_004d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0054: Unknown result type (might be due to invalid IL or missing references)
		//IL_0059: Unknown result type (might be due to invalid IL or missing references)
		//IL_0060: 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_007a: 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_0083: Unknown result type (might be due to invalid IL or missing references)
		//IL_0085: Unknown result type (might be due to invalid IL or missing references)
		//IL_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_00a4: 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_00a8: 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_00af: 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_00bc: 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_01e1: 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_00d0: Unknown result type (might be due to invalid IL or missing references)
		//IL_00de: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
		//IL_0190: Unknown result type (might be due to invalid IL or missing references)
		//IL_01aa: 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_0111: 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_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_0164: 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)
		if ((Object)(object)aimingHand == (Object)null)
		{
			return;
		}
		((Renderer)lineRenderer).enabled = true;
		Vector3 position = ((Component)aimingHand).transform.position;
		Vector3 forward = ((Component)aimingHand).transform.forward;
		Vector3 val = position + forward * 0.2f;
		Vector3 val2 = forward * arcVelocity;
		float num = 0.1f;
		Vector3 val3 = val;
		validTarget = false;
		RaycastHit val7 = default(RaycastHit);
		for (int i = 0; i < arcSegments; i++)
		{
			lineRenderer.SetPosition(i, val3);
			Vector3 val4 = val3 + val2 * num;
			val2.y -= arcGravity * num;
			Vector3 val5 = val3;
			Vector3 val6 = val4 - val3;
			if (Physics.Raycast(val5, ((Vector3)(ref val6)).normalized, ref val7, Vector3.Distance(val3, val4)))
			{
				float num2 = Vector3.Distance(val, ((RaycastHit)(ref val7)).point);
				if (Vector3.Angle(((RaycastHit)(ref val7)).normal, Vector3.up) <= prefMaxSlope.Value && num2 <= prefMaxDistance.Value)
				{
					teleportTarget = ((RaycastHit)(ref val7)).point;
					validTarget = true;
					targetMarker.SetActive(true);
					targetMarker.transform.position = ((RaycastHit)(ref val7)).point + Vector3.up * 0.15f;
					((Renderer)targetMarker.GetComponent<MeshRenderer>()).material.color = Color.green;
				}
				else
				{
					validTarget = false;
					targetMarker.SetActive(true);
					targetMarker.transform.position = ((RaycastHit)(ref val7)).point;
					((Renderer)targetMarker.GetComponent<MeshRenderer>()).material.color = Color.red;
				}
				for (int j = i; j < arcSegments; j++)
				{
					lineRenderer.SetPosition(j, ((RaycastHit)(ref val7)).point);
				}
				break;
			}
			val3 = val4;
		}
	}

	private void HideTeleportArc()
	{
		if ((Object)(object)lineRenderer != (Object)null)
		{
			((Renderer)lineRenderer).enabled = false;
		}
		if ((Object)(object)targetMarker != (Object)null)
		{
			targetMarker.SetActive(false);
		}
	}

	private void ExecuteTeleport()
	{
		//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_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_0057: Unknown result type (might be due to invalid IL or missing references)
		if (!validTarget)
		{
			return;
		}
		GameObject rigManager = Player.GetRigManager();
		if ((Object)(object)rigManager != (Object)null)
		{
			Transform physicsRig = rigManager.transform.Find("[PhysicsRig]");
			Rigidbody val = FindPelvis(physicsRig);
			if ((Object)(object)val != (Object)null)
			{
				Vector3 targetPos = teleportTarget + Vector3.up * 1f;
				MelonCoroutines.Start(TeleportSequence(physicsRig, val, targetPos));
			}
		}
	}

	private Rigidbody FindPelvis(Transform physicsRig)
	{
		foreach (Rigidbody componentsInChild in ((Component)physicsRig).GetComponentsInChildren<Rigidbody>())
		{
			if (((Object)componentsInChild).name.ToLower().Contains("pelvis"))
			{
				return componentsInChild;
			}
		}
		return null;
	}

	[IteratorStateMachine(typeof(<TeleportSequence>d__33))]
	private IEnumerator TeleportSequence(Transform physicsRig, Rigidbody pelvis, Vector3 targetPos)
	{
		//IL_001c: 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)
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <TeleportSequence>d__33(0)
		{
			<>4__this = this,
			physicsRig = physicsRig,
			pelvis = pelvis,
			targetPos = targetPos
		};
	}
}