using System;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using BoneLib;
using BoneLib.BoneMenu;
using BoneLib.Notifications;
using DynamicWalking;
using HarmonyLib;
using Il2CppSLZ.Marrow;
using MelonLoader;
using MelonLoader.Preferences;
using Microsoft.CodeAnalysis;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: MelonInfo(typeof(Mod), "Dynamic Walking", "1.1.0", "ElectroDynamic", null)]
[assembly: MelonGame("Stress Level Zero", "BONELAB")]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = ".NET 6.0")]
[assembly: AssemblyCompany("DynamicWalking")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("DynamicWalking")]
[assembly: AssemblyTitle("DynamicWalking")]
[assembly: AssemblyVersion("1.0.0.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace DynamicWalking
{
	public class Mod : MelonMod
	{
		public static MelonPreferences_Category Cat;

		public static MelonPreferences_Entry<bool> Enabled;

		public static MelonPreferences_Entry<bool> AllowRun;

		public static MelonPreferences_Entry<float> Sensitivity;

		public static MelonPreferences_Entry<float> MinStep;

		private const float StickDeadzone = 0.15f;

		private const float WalkCap = 0.6f;

		private const float BaseSpan = 0.6f;

		private const float DriftTau = 0.8f;

		private const float AttackTau = 0.06f;

		private const float ReleaseTau = 0.3f;

		private const float CadenceTau = 0.4f;

		private const float RefCadence = 2f;

		private const float RunBoost = 0.9f;

		private const float MinFlipInterval = 0.08f;

		private const float MaxFlipInterval = 1.2f;

		private const float StepTimeout = 0.55f;

		public static float GateMagnitude;

		private static float _lastHeadY;

		private static bool _hasLastHeadY;

		private static float _vDrift;

		private static float _env;

		private static int _lastSign;

		private static float _peakSinceFlip;

		private static float _lastFlipTime;

		private static float _cadence;

		public static Instance Log { get; private set; }

		public override void OnInitializeMelon()
		{
			Log = ((MelonBase)this).LoggerInstance;
			Cat = MelonPreferences.CreateCategory("DynamicWalking");
			Enabled = Cat.CreateEntry<bool>("Enabled", true, "Walk by physically stepping in place", (string)null, false, false, (ValueValidator)null, (string)null);
			AllowRun = Cat.CreateEntry<bool>("AllowRun", true, "Stepping fast enough breaks into a run", (string)null, false, false, (ValueValidator)null, (string)null);
			Sensitivity = Cat.CreateEntry<float>("Sensitivity", 1f, "How easily a head bob becomes movement", (string)null, false, false, (ValueValidator)null, (string)null);
			MinStep = Cat.CreateEntry<float>("MinStep", 0.06f, "Ignore head movement gentler than this (m/s)", (string)null, false, false, (ValueValidator)null, (string)null);
			Cat.SaveToFile(false);
			BuildMenu();
			Hooking.OnLevelLoaded += delegate
			{
				ResetBob();
			};
			Log.Msg("Dynamic Walking loaded — step in place to move.");
		}

		public override void OnUpdate()
		{
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			if (!Enabled.Value)
			{
				GateMagnitude = 0f;
				return;
			}
			Transform val = null;
			try
			{
				val = Player.Head;
			}
			catch
			{
			}
			if ((Object)(object)val == (Object)null)
			{
				ResetBob();
				return;
			}
			float deltaTime = Time.deltaTime;
			if (deltaTime <= 0f)
			{
				return;
			}
			float y = val.position.y;
			if (!_hasLastHeadY)
			{
				_lastHeadY = y;
				_hasLastHeadY = true;
				return;
			}
			float num = (y - _lastHeadY) / deltaTime;
			_lastHeadY = y;
			_vDrift = Mathf.Lerp(_vDrift, num, 1f - Mathf.Exp((0f - deltaTime) / 0.8f));
			float num2 = num - _vDrift;
			float num3 = Mathf.Abs(num2);
			float time = Time.time;
			int num4 = ((num2 > MinStep.Value) ? 1 : ((num2 < 0f - MinStep.Value) ? (-1) : 0));
			if (num3 > _peakSinceFlip)
			{
				_peakSinceFlip = num3;
			}
			if (num4 != 0)
			{
				if (_lastSign != 0 && num4 != _lastSign && _peakSinceFlip > MinStep.Value)
				{
					float num5 = time - _lastFlipTime;
					if (num5 > 0.08f && num5 < 1.2f)
					{
						float num6 = 0.5f / num5;
						_cadence = ((_cadence <= 0f) ? num6 : Mathf.Lerp(_cadence, num6, 1f - Mathf.Exp((0f - num5) / 0.4f)));
					}
					_lastFlipTime = time;
					_peakSinceFlip = 0f;
				}
				_lastSign = num4;
			}
			float num7 = ((num3 > _env) ? 0.06f : 0.3f);
			_env = Mathf.Lerp(_env, num3, 1f - Mathf.Exp((0f - deltaTime) / num7));
			bool num8 = time - _lastFlipTime < 0.55f;
			float num9 = 0f;
			if (num8)
			{
				float num10 = Mathf.Max(0.1f, Sensitivity.Value);
				float num11 = Mathf.Max(0.05f, 0.6f / num10);
				float num12 = Mathf.Clamp01((_env - MinStep.Value) / num11);
				float num13 = Mathf.Clamp01(_cadence / Mathf.Max(0.5f, 2f / num10));
				num9 = Mathf.Clamp01(num12 * (1f + 0.9f * num13));
			}
			else
			{
				_cadence = Mathf.Lerp(_cadence, 0f, 1f - Mathf.Exp((0f - deltaTime) / 0.3f));
				_lastSign = 0;
			}
			if (!AllowRun.Value)
			{
				num9 = Mathf.Min(num9, 0.6f);
			}
			GateMagnitude = num9;
		}

		private static void ResetBob()
		{
			_hasLastHeadY = false;
			_vDrift = 0f;
			_env = 0f;
			_lastSign = 0;
			_peakSinceFlip = 0f;
			_lastFlipTime = -999f;
			_cadence = 0f;
			GateMagnitude = 0f;
		}

		private static void BuildMenu()
		{
			//IL_0019: 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_0065: 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_00f7: 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_017e: Unknown result type (might be due to invalid IL or missing references)
			Page obj = Page.Root.CreatePage("Dynamic Walking", new Color(0.2f, 0.8f, 1f), 0, true);
			obj.CreateBool("Dynamic Walking", Color.green, Enabled.Value, (Action<bool>)delegate(bool v)
			{
				Enabled.Value = v;
				Cat.SaveToFile(false);
				if (!v)
				{
					ResetBob();
				}
				Notify(v ? "Dynamic Walking on — step in place to move." : "Dynamic Walking off — back to normal stick movement.", (NotificationType)0);
			});
			obj.CreateBool("Activate Running", Color.cyan, AllowRun.Value, (Action<bool>)delegate(bool v)
			{
				AllowRun.Value = v;
				Cat.SaveToFile(false);
				Notify(v ? "Running on — step quickly to break into a run." : "Running off — capped at a walk.", (NotificationType)0);
			});
			obj.CreateFloat("Step Sensitivity", Color.yellow, Sensitivity.Value, 0.1f, 0.3f, 3f, (Action<float>)delegate(float v)
			{
				Sensitivity.Value = v;
				Cat.SaveToFile(false);
			});
			obj.CreateFloat("Min Step Strength", new Color(1f, 0.6f, 0.2f), MinStep.Value, 0.01f, 0f, 0.25f, (Action<float>)delegate(float v)
			{
				MinStep.Value = v;
				Cat.SaveToFile(false);
			});
			obj.CreateFunction("Reset Defaults", Color.red, (Action)delegate
			{
				Sensitivity.Value = 1f;
				MinStep.Value = 0.06f;
				AllowRun.Value = true;
				Cat.SaveToFile(false);
				ResetBob();
				Notify("Settings reset to defaults.", (NotificationType)3);
			});
			obj.CreateFunction(" - push stick to aim, step in place to go", new Color(0.6f, 0.6f, 0.6f), (Action)delegate
			{
			});
		}

		private static void Notify(string message, NotificationType type)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0021: 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_002d: 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_0038: Expected O, but got Unknown
			try
			{
				Notifier.Send(new Notification
				{
					Title = NotificationText.op_Implicit("Dynamic Walking"),
					Message = NotificationText.op_Implicit(message),
					PopupLength = 2.5f,
					Type = type
				});
			}
			catch
			{
			}
		}
	}
	[HarmonyPatch(typeof(RemapRig), "ApplyMovement", new Type[]
	{
		typeof(Vector2),
		typeof(bool),
		typeof(float)
	})]
	public static class ApplyMovement_Patch
	{
		public static void Prefix(ref Vector2 axis, ref bool inputPressed, float deltaTime)
		{
			//IL_002c: 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_0037: 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_0022: 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_0054: 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_0059: Unknown result type (might be due to invalid IL or missing references)
			if (Mod.Enabled.Value)
			{
				float magnitude = ((Vector2)(ref axis)).magnitude;
				if (magnitude < 0.15f)
				{
					axis = Vector2.zero;
					inputPressed = false;
					return;
				}
				Vector2 val = axis / magnitude;
				float gateMagnitude = Mod.GateMagnitude;
				bool flag = gateMagnitude > 0.001f;
				axis = (flag ? (val * gateMagnitude) : Vector2.zero);
				inputPressed = flag;
			}
		}
	}
}