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 BepInEx;
using HarmonyLib;
using Peak.Afflictions;
using Photon.Pun;
using Photon.Realtime;
using UnityEngine;
using UnityEngine.SceneManagement;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: AssemblyTitle("점핑피크")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("점핑피크")]
[assembly: AssemblyCopyright("Copyright ©  2026")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("e76b4db5-556b-4707-86df-0fd835832607")]
[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")]
[BepInPlugin("Sapphire009.BeforeStart", "BeforeStart", "1.0.1")]
public sealed class BeforeStart : BaseUnityPlugin
{
	[HarmonyPatch(typeof(CharacterMovement), "TryToJump")]
	private static class CharacterMovementTryToJumpPatch
	{
		[HarmonyPrefix]
		[HarmonyPriority(800)]
		private static bool Prefix(CharacterMovement __instance)
		{
			if (!ShouldBlockJump(__instance, out var _))
			{
				return true;
			}
			CaptureOriginalJumpImpulse(__instance);
			RestoreOriginalJumpImpulse(__instance);
			return false;
		}
	}

	[HarmonyPatch(typeof(CharacterMovement), "JumpRpc", new Type[] { typeof(bool) })]
	private static class CharacterMovementJumpRpcPatch
	{
		[HarmonyPrefix]
		[HarmonyPriority(800)]
		[HarmonyBefore(new string[] { "Sapphire009.JumpingPEAK", "Sapphire009.NoGround" })]
		private static bool Prefix(CharacterMovement __instance, bool __0, out bool __state)
		{
			__state = false;
			if (!ShouldBlockJump(__instance, out var _))
			{
				return true;
			}
			CaptureOriginalJumpImpulse(__instance);
			RestoreOriginalJumpImpulse(__instance);
			__state = true;
			return false;
		}

		[HarmonyPostfix]
		[HarmonyPriority(0)]
		[HarmonyAfter(new string[] { "Sapphire009.JumpingPEAK", "Sapphire009.NoGround" })]
		private static void Postfix(CharacterMovement __instance, bool __state)
		{
			if (__state)
			{
				RestoreOriginalJumpImpulse(__instance);
			}
		}
	}

	public const string PluginGUID = "Sapphire009.BeforeStart";

	public const string PluginName = "BeforeStart";

	public const string PluginVersion = "1.0.1";

	private const float MinimumJumpLockDuration = 10f;

	private const float MaximumJumpLockDuration = 15f;

	private static bool airportWasVisited;

	private static bool waitingForFirstMapCharacter;

	private static bool firstMapProtectionConsumed;

	private static int protectedSceneHandle = -1;

	private static bool jumpLockActive;

	private static int protectedCharacterId = -1;

	private static float jumpLockStartedAt;

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

	private Harmony harmony;

	private void Awake()
	{
		//IL_0007: Unknown result type (might be due to invalid IL or missing references)
		//IL_0011: Expected O, but got Unknown
		//IL_002f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0034: Unknown result type (might be due to invalid IL or missing references)
		//IL_0035: Unknown result type (might be due to invalid IL or missing references)
		harmony = new Harmony("Sapphire009.BeforeStart");
		harmony.PatchAll();
		SceneManager.sceneLoaded += OnSceneLoaded;
		Scene activeScene = SceneManager.GetActiveScene();
		if (IsAirportScene(activeScene))
		{
			RegisterAirportVisit();
		}
	}

	private void Update()
	{
		TryStartJumpLock();
		UpdateJumpLock();
	}

	private void OnDestroy()
	{
		SceneManager.sceneLoaded -= OnSceneLoaded;
		ResetAllState();
		if (harmony != null)
		{
			harmony.UnpatchSelf();
			harmony = null;
		}
	}

	private static void OnSceneLoaded(Scene scene, LoadSceneMode loadSceneMode)
	{
		//IL_0001: 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_0032: Unknown result type (might be due to invalid IL or missing references)
		if (IsAirportScene(scene))
		{
			RegisterAirportVisit();
		}
		else if (airportWasVisited && !firstMapProtectionConsumed && IsGameplayMapScene(scene))
		{
			protectedSceneHandle = SceneHandle.op_Implicit(((Scene)(ref scene)).handle);
			waitingForFirstMapCharacter = true;
			jumpLockActive = false;
			protectedCharacterId = -1;
			OriginalJumpImpulses.Clear();
		}
	}

	private static void RegisterAirportVisit()
	{
		airportWasVisited = true;
		waitingForFirstMapCharacter = false;
		firstMapProtectionConsumed = false;
		protectedSceneHandle = -1;
		jumpLockActive = false;
		protectedCharacterId = -1;
		jumpLockStartedAt = 0f;
		OriginalJumpImpulses.Clear();
	}

	private static void TryStartJumpLock()
	{
		//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_0024: 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)
		if (!waitingForFirstMapCharacter || jumpLockActive)
		{
			return;
		}
		Scene activeScene = SceneManager.GetActiveScene();
		if (((Scene)(ref activeScene)).handle != SceneHandle.op_Implicit(protectedSceneHandle))
		{
			return;
		}
		Character localCharacter = Character.localCharacter;
		if ((Object)(object)localCharacter == (Object)null || !localCharacter.IsLocal || (Object)(object)localCharacter.data == (Object)null)
		{
			return;
		}
		CharacterMovement val = ResolveMovement(localCharacter);
		if (!((Object)(object)val == (Object)null))
		{
			protectedCharacterId = ((Object)localCharacter).GetInstanceID();
			jumpLockStartedAt = Time.time;
			jumpLockActive = true;
			waitingForFirstMapCharacter = false;
			firstMapProtectionConsumed = true;
			int instanceID = ((Object)val).GetInstanceID();
			if (val.jumpImpulse > 0f)
			{
				OriginalJumpImpulses[instanceID] = val.jumpImpulse;
			}
		}
	}

	private static void UpdateJumpLock()
	{
		if (!jumpLockActive)
		{
			return;
		}
		Character localCharacter = Character.localCharacter;
		if ((Object)(object)localCharacter == (Object)null || !localCharacter.IsLocal || ((Object)localCharacter).GetInstanceID() != protectedCharacterId || (Object)(object)localCharacter.data == (Object)null)
		{
			EndJumpLock();
			return;
		}
		float num = Time.time - jumpLockStartedAt;
		bool flag = num >= 10f;
		bool flag2 = num >= 15f;
		bool flag3 = HasCharacterFinishedWaking(localCharacter);
		if ((flag && flag3) || flag2)
		{
			EndJumpLock();
		}
	}

	private static bool HasCharacterFinishedWaking(Character character)
	{
		if ((Object)(object)character == (Object)null || (Object)(object)character.data == (Object)null)
		{
			return false;
		}
		if (character.data.dead || character.data.fullyPassedOut || character.data.passedOut)
		{
			return false;
		}
		if (character.data.fallSeconds > 0.01f)
		{
			return false;
		}
		if (character.data.passedOutOnTheBeach > 0f)
		{
			return false;
		}
		if (character.data.currentRagdollControll < 0.9f)
		{
			return false;
		}
		if (character.data.GetTargetRagdollControll() < 0.9f)
		{
			return false;
		}
		return true;
	}

	private static void EndJumpLock()
	{
		if (jumpLockActive)
		{
			Character localCharacter = Character.localCharacter;
			CharacterMovement movement = ResolveMovement(localCharacter);
			RestoreOriginalJumpImpulse(movement);
			jumpLockActive = false;
			protectedCharacterId = -1;
			jumpLockStartedAt = 0f;
			OriginalJumpImpulses.Clear();
		}
	}

	internal static bool ShouldBlockJump(CharacterMovement movement, out Character character)
	{
		//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_0065: Unknown result type (might be due to invalid IL or missing references)
		character = ResolveCharacter((Component)(object)movement);
		if (!jumpLockActive || (Object)(object)movement == (Object)null || (Object)(object)character == (Object)null || !character.IsLocal)
		{
			return false;
		}
		if (((Object)character).GetInstanceID() != protectedCharacterId)
		{
			return false;
		}
		Scene activeScene = SceneManager.GetActiveScene();
		if (((Scene)(ref activeScene)).handle != SceneHandle.op_Implicit(protectedSceneHandle))
		{
			return false;
		}
		return true;
	}

	private static Character ResolveCharacter(Component component)
	{
		if ((Object)(object)component == (Object)null)
		{
			return null;
		}
		Character val = component.GetComponent<Character>();
		if ((Object)(object)val == (Object)null)
		{
			val = component.GetComponentInParent<Character>();
		}
		return val;
	}

	private static CharacterMovement ResolveMovement(Character character)
	{
		if ((Object)(object)character == (Object)null)
		{
			return null;
		}
		if (character.refs != null && (Object)(object)character.refs.movement != (Object)null)
		{
			return character.refs.movement;
		}
		CharacterMovement val = ((Component)character).GetComponent<CharacterMovement>();
		if ((Object)(object)val == (Object)null)
		{
			val = ((Component)character).GetComponentInParent<CharacterMovement>();
		}
		return val;
	}

	private static void CaptureOriginalJumpImpulse(CharacterMovement movement)
	{
		if (!((Object)(object)movement == (Object)null))
		{
			int instanceID = ((Object)movement).GetInstanceID();
			if (!OriginalJumpImpulses.ContainsKey(instanceID) && !(movement.jumpImpulse <= 0f))
			{
				OriginalJumpImpulses.Add(instanceID, movement.jumpImpulse);
			}
		}
	}

	private static void RestoreOriginalJumpImpulse(CharacterMovement movement)
	{
		if (!((Object)(object)movement == (Object)null) && OriginalJumpImpulses.TryGetValue(((Object)movement).GetInstanceID(), out var value))
		{
			movement.jumpImpulse = value;
		}
	}

	private static bool IsAirportScene(Scene scene)
	{
		if (!((Scene)(ref scene)).IsValid() || string.IsNullOrEmpty(((Scene)(ref scene)).name))
		{
			return false;
		}
		return ((Scene)(ref scene)).name.IndexOf("Airport", StringComparison.OrdinalIgnoreCase) >= 0;
	}

	private static bool IsGameplayMapScene(Scene scene)
	{
		if (!((Scene)(ref scene)).IsValid() || string.IsNullOrEmpty(((Scene)(ref scene)).name))
		{
			return false;
		}
		return ((Scene)(ref scene)).name.StartsWith("Level_", StringComparison.OrdinalIgnoreCase);
	}

	private static void ResetAllState()
	{
		airportWasVisited = false;
		waitingForFirstMapCharacter = false;
		firstMapProtectionConsumed = false;
		protectedSceneHandle = -1;
		jumpLockActive = false;
		protectedCharacterId = -1;
		jumpLockStartedAt = 0f;
		OriginalJumpImpulses.Clear();
	}
}
[BepInPlugin("Sapphire009.ClimbX", "ClimbX", "1.0.1")]
public sealed class ClimbX : BaseUnityPlugin
{
	[HarmonyPatch(typeof(CharacterClimbing), "CanClimb")]
	private static class CharacterClimbingCanClimbPatch
	{
		[HarmonyPrefix]
		private static bool Prefix(CharacterClimbing __instance, ref bool __result)
		{
			if (!ShouldBlockWallGrab(__instance, out var _))
			{
				return true;
			}
			__result = false;
			return false;
		}
	}

	[HarmonyPatch(typeof(CharacterClimbing), "TryToStartWallClimb", new Type[]
	{
		typeof(bool),
		typeof(Vector3),
		typeof(bool),
		typeof(float)
	})]
	private static class TryToStartWallClimbPatch
	{
		[HarmonyPrefix]
		private static bool Prefix(CharacterClimbing __instance)
		{
			if (!ShouldBlockWallGrab(__instance, out var _))
			{
				return true;
			}
			return false;
		}
	}

	public const string PluginGUID = "Sapphire009.ClimbX";

	public const string PluginName = "ClimbX";

	public const string PluginVersion = "1.0.1";

	private Harmony harmony;

	private void Awake()
	{
		//IL_0007: Unknown result type (might be due to invalid IL or missing references)
		//IL_0011: Expected O, but got Unknown
		harmony = new Harmony("Sapphire009.ClimbX");
		harmony.PatchAll();
	}

	private void OnDestroy()
	{
		if (harmony != null)
		{
			harmony.UnpatchSelf();
			harmony = null;
		}
	}

	internal static bool IsAirportScene()
	{
		//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)
		Scene activeScene = SceneManager.GetActiveScene();
		string name = ((Scene)(ref activeScene)).name;
		if (string.IsNullOrEmpty(name))
		{
			return false;
		}
		return name.IndexOf("Airport", StringComparison.OrdinalIgnoreCase) >= 0;
	}

	internal static Character ResolveCharacter(Component component)
	{
		if ((Object)(object)component == (Object)null)
		{
			return null;
		}
		Character val = component.GetComponent<Character>();
		if ((Object)(object)val == (Object)null)
		{
			val = component.GetComponentInParent<Character>();
		}
		return val;
	}

	internal static bool ShouldBlockWallGrab(CharacterClimbing climbing, out Character character)
	{
		character = ResolveCharacter((Component)(object)climbing);
		if ((Object)(object)character == (Object)null || !character.IsLocal || (Object)(object)character.data == (Object)null)
		{
			return false;
		}
		if (IsAirportScene())
		{
			return false;
		}
		return true;
	}
}
[BepInPlugin("Sapphire009.HelpUp", "HelpUp", "0.0.2")]
public sealed class HelpUp : BaseUnityPlugin
{
	[HarmonyPatch(typeof(CharacterGrabbing), "Reach")]
	private static class CharacterGrabbingReachPatch
	{
		[HarmonyPrefix]
		private static bool Prefix(CharacterGrabbing __instance)
		{
			Character val = ResolveCharacter((Component)(object)__instance);
			if ((Object)(object)val == (Object)null || (Object)(object)val.data == (Object)null || val.refs == null || IsAirportScene())
			{
				return true;
			}
			RunExtendedReach(val);
			return false;
		}
	}

	[HarmonyPatch(typeof(CharacterAnimations), "Update")]
	private static class CharacterAnimationsUpdatePatch
	{
		[HarmonyPostfix]
		private static void Postfix(CharacterAnimations __instance)
		{
			Character val = ResolveCharacter((Component)(object)__instance);
			if (!((Object)(object)val == (Object)null) && !((Object)(object)val.data == (Object)null) && val.refs != null && !((Object)(object)val.refs.animator == (Object)null) && !IsAirportScene() && val.data.isReaching && val.data.grabFriendDistance <= 10f)
			{
				val.refs.animator.SetBool(HelpAnimatorHash, true);
			}
		}
	}

	public const string PluginGUID = "Sapphire009.HelpUp";

	public const string PluginName = "HelpUp";

	public const string PluginVersion = "0.0.2";

	private const float ExtendedHelpRange = 10f;

	private const float NativeHelpRange = 4f;

	private const float NativePullForce = 70f;

	private const float MaximumPullForce = 95f;

	private const float MaximumHelpAngle = 65f;

	private const float MinimumAirborneTime = 0.12f;

	private const float MaximumTargetHeightAboveHelper = 1.5f;

	private static readonly int HelpAnimatorHash = Animator.StringToHash("Help");

	private Harmony harmony;

	private void Awake()
	{
		//IL_0007: Unknown result type (might be due to invalid IL or missing references)
		//IL_0011: Expected O, but got Unknown
		harmony = new Harmony("Sapphire009.HelpUp");
		harmony.PatchAll();
	}

	private void OnDestroy()
	{
		if (harmony != null)
		{
			harmony.UnpatchSelf();
			harmony = null;
		}
	}

	internal static bool IsAirportScene()
	{
		//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)
		Scene activeScene = SceneManager.GetActiveScene();
		string name = ((Scene)(ref activeScene)).name;
		if (string.IsNullOrEmpty(name))
		{
			return false;
		}
		return name.IndexOf("Airport", StringComparison.OrdinalIgnoreCase) >= 0;
	}

	private static Character ResolveCharacter(Component component)
	{
		if ((Object)(object)component == (Object)null)
		{
			return null;
		}
		Character val = component.GetComponent<Character>();
		if ((Object)(object)val == (Object)null)
		{
			val = component.GetComponentInParent<Character>();
		}
		return val;
	}

	private static bool CanUseExtendedHelp(Character helper)
	{
		if ((Object)(object)helper == (Object)null || (Object)(object)helper.data == (Object)null || helper.refs == null || (Object)(object)helper.refs.view == (Object)null)
		{
			return false;
		}
		if (IsAirportScene())
		{
			return false;
		}
		return helper.data.isReaching;
	}

	private static bool TargetCanBeHelped(Character helper, Character target)
	{
		//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_0149: 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)
		if ((Object)(object)helper == (Object)null || (Object)(object)target == (Object)null || (Object)(object)target == (Object)(object)helper || (Object)(object)target.data == (Object)null || target.refs == null || (Object)(object)target.refs.view == (Object)null || (Object)(object)target.refs.afflictions == (Object)null)
		{
			return false;
		}
		if (target.data.dead)
		{
			return false;
		}
		bool flag = target.IsStuck() || target.data.sinceUnstuck < 1f;
		bool isWebbed = target.refs.afflictions.isWebbed;
		bool flag2 = target.data.isClimbing && target.Center.y < helper.Center.y + 1f;
		bool flag3 = target.data.fallSeconds > 0.01f;
		bool flag4 = target.data.passedOut || target.data.fullyPassedOut || target.data.passedOutOnTheBeach > 0f;
		bool flag5 = !target.data.isGrounded && target.data.sinceGrounded > 0.12f;
		bool flag6 = target.Center.y <= helper.Center.y + 1.5f;
		if (flag || isWebbed || flag2)
		{
			return true;
		}
		if (!flag6)
		{
			return false;
		}
		return flag5 || flag3 || flag4;
	}

	private static bool HasClearLineOfSight(Character helper, Character target)
	{
		//IL_001e: 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_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)
		if ((Object)(object)helper == (Object)null || (Object)(object)target == (Object)null)
		{
			return false;
		}
		RaycastHit val = HelperFunctions.LineCheck(helper.Center, target.Center, (LayerType)1, 0f, (QueryTriggerInteraction)1);
		return (Object)(object)((RaycastHit)(ref val)).transform == (Object)null;
	}

	private static float CalculatePullForce(float distance)
	{
		float num = Mathf.InverseLerp(4f, 10f, distance);
		return Mathf.Lerp(70f, 95f, num);
	}

	private static void ShowGraspEffect()
	{
		if (!((Object)(object)GUIManager.instance == (Object)null))
		{
			GUIManager.instance.Grasp();
		}
	}

	private static void UnstickCharacter(Character target)
	{
		if (!((Object)(object)target == (Object)null) && target.refs != null && !((Object)(object)target.refs.view == (Object)null))
		{
			target.refs.view.RPC("RPCA_Unstick", (RpcTarget)0, Array.Empty<object>());
		}
	}

	private static void DragCharacterTowards(Character target, Vector3 destination, float force)
	{
		//IL_0051: 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_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_006a: 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_0070: 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)
		//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)target == (Object)null || target.refs == null || (Object)(object)target.refs.ragdoll == (Object)null || target.refs.ragdoll.partList == null)
		{
			return;
		}
		target.dragTowardsAction?.Invoke(destination, force);
		Vector3 val = Vector3.ClampMagnitude(destination - target.Center, 1f);
		Vector3 val2 = val * force;
		foreach (Bodypart part in target.refs.ragdoll.partList)
		{
			if (!((Object)(object)part == (Object)null))
			{
				part.AddForce(val2, (ForceMode)5);
			}
		}
	}

	private static void LimitCharacterFalling(Character target)
	{
		if (!((Object)(object)target == (Object)null) && !((Object)(object)target.data == (Object)null))
		{
			target.data.sinceGrounded = Mathf.Min(target.data.sinceGrounded, 0.5f);
			target.data.sinceJump = Mathf.Min(target.data.sinceJump, 0.5f);
		}
	}

	private static void RunExtendedReach(Character helper)
	{
		//IL_004b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0051: Unknown result type (might be due to invalid IL or missing references)
		//IL_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_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_018a: Unknown result type (might be due to invalid IL or missing references)
		if (!CanUseExtendedHelp(helper))
		{
			return;
		}
		float num = 100f;
		foreach (Character allCharacter in Character.AllCharacters)
		{
			if (!TargetCanBeHelped(helper, allCharacter))
			{
				continue;
			}
			Vector3 val = allCharacter.Center - helper.Center;
			float sqrMagnitude = ((Vector3)(ref val)).sqrMagnitude;
			if (sqrMagnitude > num)
			{
				continue;
			}
			float num2 = Mathf.Sqrt(sqrMagnitude);
			if (num2 <= 0.001f)
			{
				continue;
			}
			float num3 = Vector3.Angle(helper.data.lookDirection, val);
			if (!(num3 > 65f) && HasClearLineOfSight(helper, allCharacter))
			{
				if (allCharacter.IsStuck() && allCharacter.IsLocal)
				{
					UnstickCharacter(allCharacter);
				}
				allCharacter.refs.afflictions.SubtractStatus((STATUSTYPE)11, 1f, false, false);
				if (num2 < helper.data.grabFriendDistance)
				{
					helper.data.grabFriendDistance = num2;
					helper.data.sinceGrabFriend = 0f;
				}
				if (helper.refs.view.IsMine)
				{
					ShowGraspEffect();
				}
				if (allCharacter.refs.view.IsMine)
				{
					float force = CalculatePullForce(num2);
					DragCharacterTowards(allCharacter, helper.Center, force);
					LimitCharacterFalling(allCharacter);
					ShowGraspEffect();
				}
			}
		}
	}
}
[BepInPlugin("Sapphire009.JumpingPEAK", "JumpingPEAK", "1.0.2")]
public sealed class JumpingPEAK : BaseUnityPlugin
{
	private sealed class StandRecoveryState
	{
		public bool WaitingForStand;

		public float StableSince = -1f;
	}

	[HarmonyPatch(typeof(CharacterInput), "Sample", new Type[] { typeof(bool) })]
	private static class CharacterInputSamplePatch
	{
		[HarmonyPostfix]
		[HarmonyPriority(800)]
		[HarmonyBefore(new string[] { "Sapphire009.WASDX" })]
		private static void Postfix(CharacterInput __instance)
		{
			StoreInput(__instance);
		}
	}

	[HarmonyPatch(typeof(CharacterMovement), "Update")]
	private static class CharacterMovementUpdatePatch
	{
		[HarmonyPostfix]
		private static void Postfix(CharacterMovement __instance)
		{
			Character character = ResolveCharacter((Component)(object)__instance);
			UpdateStandRecovery(character);
		}
	}

	[HarmonyPatch(typeof(CharacterMovement), "TryToJump")]
	private static class CharacterMovementTryToJumpPatch
	{
		[HarmonyPrefix]
		[HarmonyPriority(800)]
		[HarmonyBefore(new string[] { "Sapphire009.BeforeStart", "Sapphire009.NoGround" })]
		private static bool Prefix(CharacterMovement __instance)
		{
			Character val = ResolveCharacter((Component)(object)__instance);
			if ((Object)(object)val == (Object)null || !val.IsLocal || IsAirportScene())
			{
				return true;
			}
			if (!ShouldBlockJump(val))
			{
				return true;
			}
			CharacterMovementJumpRpcPatch.RestoreOriginalJumpImpulse(__instance);
			return false;
		}
	}

	[HarmonyPatch(typeof(CharacterMovement), "JumpRpc", new Type[] { typeof(bool) })]
	private static class CharacterMovementJumpRpcPatch
	{
		private sealed class JumpPatchState
		{
			public Character Character;

			public Vector2 MovementInput = Vector2.zero;

			public Vector3 MovementDirection = Vector3.zero;

			public float DirectionalSpeed;

			public bool ApplyDirectionalBoost;

			public bool ShiftBoosted;

			public bool WasGrounded;
		}

		private const float ControlledJumpMultiplier = 5f;

		private const float ShiftBoostMultiplier = 2f;

		private const float DirectionalJumpSpeed = 15f;

		private const float ShiftDirectionalSpeedMultiplier = 2f;

		private const int MaximumTakeoffWaitFrames = 30;

		private static readonly WaitForFixedUpdate WaitForPhysics = new WaitForFixedUpdate();

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

		[HarmonyPrefix]
		[HarmonyPriority(800)]
		[HarmonyBefore(new string[] { "Sapphire009.NoGround" })]
		private static bool Prefix(CharacterMovement __instance, bool __0, out JumpPatchState __state)
		{
			//IL_015a: 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_0162: 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)
			//IL_0177: 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_0180: Unknown result type (might be due to invalid IL or missing references)
			__state = new JumpPatchState();
			bool flag = __0;
			if ((Object)(object)__instance == (Object)null)
			{
				return true;
			}
			Character val = ResolveCharacter((Component)(object)__instance);
			if ((Object)(object)val == (Object)null)
			{
				return true;
			}
			if (!val.IsLocal)
			{
				return true;
			}
			if ((Object)(object)val.data == (Object)null)
			{
				return true;
			}
			if ((Object)(object)val.input == (Object)null)
			{
				return true;
			}
			CaptureOriginalJumpImpulse(__instance);
			RestoreOriginalJumpImpulse(__instance);
			if (!OriginalJumpImpulses.TryGetValue(((Object)__instance).GetInstanceID(), out var value))
			{
				return true;
			}
			if (value <= 0f)
			{
				return true;
			}
			if (IsAirportScene() || flag)
			{
				return true;
			}
			if (ShouldBlockJump(val))
			{
				RestoreOriginalJumpImpulse(__instance);
				return false;
			}
			bool isGrounded = val.data.isGrounded;
			bool shiftHeld = GetShiftHeld(val);
			bool flag2 = isGrounded && shiftHeld;
			float num = 5f;
			float num2 = 15f;
			if (flag2)
			{
				num *= 2f;
				num2 *= 2f;
			}
			__instance.jumpImpulse = value * num;
			Vector2 movementInput = GetMovementInput(val);
			Vector3 movementDirection = CalculateMovementDirection(val, movementInput);
			__state.Character = val;
			__state.MovementInput = movementInput;
			__state.MovementDirection = movementDirection;
			__state.DirectionalSpeed = num2;
			__state.ApplyDirectionalBoost = ((Vector3)(ref movementDirection)).sqrMagnitude > 0.0001f;
			__state.ShiftBoosted = flag2;
			__state.WasGrounded = isGrounded;
			return true;
		}

		[HarmonyPostfix]
		private static void Postfix(CharacterMovement __instance, JumpPatchState __state)
		{
			if (!((Object)(object)__instance == (Object)null) && __state != null && __state.ApplyDirectionalBoost && !((Object)(object)__state.Character == (Object)null))
			{
				((MonoBehaviour)__instance).StartCoroutine(ApplyDirectionalVelocityAfterTakeoff(__state));
			}
		}

		private static void CaptureOriginalJumpImpulse(CharacterMovement movement)
		{
			if (!((Object)(object)movement == (Object)null))
			{
				int instanceID = ((Object)movement).GetInstanceID();
				if (!OriginalJumpImpulses.ContainsKey(instanceID) && !(movement.jumpImpulse <= 0f))
				{
					OriginalJumpImpulses.Add(instanceID, movement.jumpImpulse);
				}
			}
		}

		internal static void RestoreOriginalJumpImpulse(CharacterMovement movement)
		{
			if (!((Object)(object)movement == (Object)null))
			{
				CaptureOriginalJumpImpulse(movement);
				if (OriginalJumpImpulses.TryGetValue(((Object)movement).GetInstanceID(), out var value))
				{
					movement.jumpImpulse = value;
				}
			}
		}

		private static Vector3 CalculateMovementDirection(Character character, Vector2 movementInput)
		{
			//IL_0043: 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_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_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_0165: 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_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_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_010d: 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_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_011c: 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_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_015c: 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_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 ((Object)(object)character == (Object)null || (Object)(object)character.data == (Object)null || ((Vector2)(ref movementInput)).sqrMagnitude <= 0.0001f)
			{
				return Vector3.zero;
			}
			Vector3 val = character.data.lookDirection_Flat;
			val.y = 0f;
			if (((Vector3)(ref val)).sqrMagnitude <= 0.0001f)
			{
				val = character.data.lookDirection;
				val.y = 0f;
			}
			if (((Vector3)(ref val)).sqrMagnitude > 0.0001f)
			{
				((Vector3)(ref val)).Normalize();
			}
			Vector3 val2 = character.data.lookDirection_Right;
			val2.y = 0f;
			if (((Vector3)(ref val2)).sqrMagnitude <= 0.0001f && ((Vector3)(ref val)).sqrMagnitude > 0.0001f)
			{
				val2 = Vector3.Cross(Vector3.up, val);
			}
			if (((Vector3)(ref val2)).sqrMagnitude > 0.0001f)
			{
				((Vector3)(ref val2)).Normalize();
			}
			Vector3 val3 = val * movementInput.y;
			val3 += val2 * movementInput.x;
			val3.y = 0f;
			if (((Vector3)(ref val3)).sqrMagnitude <= 0.0001f)
			{
				return Vector3.zero;
			}
			return ((Vector3)(ref val3)).normalized;
		}

		private static IEnumerator ApplyDirectionalVelocityAfterTakeoff(JumpPatchState state)
		{
			for (int frame = 0; frame < 30; frame++)
			{
				yield return WaitForPhysics;
				Character character = state.Character;
				if ((Object)(object)character == (Object)null || !character.IsLocal || (Object)(object)character.data == (Object)null || character.data.dead || character.data.fullyPassedOut)
				{
					break;
				}
				if (!character.data.isGrounded && character.data.sinceJump < 0.3f)
				{
					ApplyDirectionalVelocity(character, state);
					break;
				}
			}
		}

		private static void ApplyDirectionalVelocity(Character character, JumpPatchState state)
		{
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: 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_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_00e3: 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_00fd: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)character == (Object)null || character.refs == null || (Object)(object)character.refs.ragdoll == (Object)null || character.refs.ragdoll.partList == null || state == null || ((Vector3)(ref state.MovementDirection)).sqrMagnitude <= 0.0001f)
			{
				return;
			}
			Vector3 val = state.MovementDirection * state.DirectionalSpeed;
			for (int i = 0; i < character.refs.ragdoll.partList.Count; i++)
			{
				Bodypart val2 = character.refs.ragdoll.partList[i];
				if (!((Object)(object)val2 == (Object)null) && !((Object)(object)val2.Rig == (Object)null))
				{
					Rigidbody rig = val2.Rig;
					if (!rig.isKinematic)
					{
						Vector3 linearVelocity = rig.linearVelocity;
						linearVelocity.x = val.x;
						linearVelocity.z = val.z;
						rig.linearVelocity = linearVelocity;
					}
				}
			}
		}

		internal static void ClearCache()
		{
			OriginalJumpImpulses.Clear();
		}
	}

	public const string PluginGUID = "Sapphire009.JumpingPEAK";

	public const string PluginName = "JumpingPEAK";

	public const string PluginVersion = "1.0.2";

	private static readonly Dictionary<int, Vector2> CapturedMovementInputs = new Dictionary<int, Vector2>();

	private static readonly Dictionary<int, bool> CapturedShiftInputs = new Dictionary<int, bool>();

	private static readonly Dictionary<int, StandRecoveryState> StandRecoveryStates = new Dictionary<int, StandRecoveryState>();

	private const float StandConfirmationDuration = 0.35f;

	private const float RagdollControlThreshold = 0.9f;

	private Harmony harmony;

	private void Awake()
	{
		//IL_0007: Unknown result type (might be due to invalid IL or missing references)
		//IL_0011: Expected O, but got Unknown
		harmony = new Harmony("Sapphire009.JumpingPEAK");
		harmony.PatchAll();
	}

	private void OnDestroy()
	{
		CharacterMovementJumpRpcPatch.ClearCache();
		CapturedMovementInputs.Clear();
		CapturedShiftInputs.Clear();
		StandRecoveryStates.Clear();
		if (harmony != null)
		{
			harmony.UnpatchSelf();
			harmony = null;
		}
	}

	internal static bool IsAirportScene()
	{
		//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)
		Scene activeScene = SceneManager.GetActiveScene();
		string name = ((Scene)(ref activeScene)).name;
		if (string.IsNullOrEmpty(name))
		{
			return false;
		}
		return name.IndexOf("Airport", StringComparison.OrdinalIgnoreCase) >= 0;
	}

	private static Character ResolveCharacter(Component component)
	{
		if ((Object)(object)component == (Object)null)
		{
			return null;
		}
		Character val = component.GetComponent<Character>();
		if ((Object)(object)val == (Object)null)
		{
			val = component.GetComponentInParent<Character>();
		}
		return val;
	}

	private static void StoreInput(CharacterInput characterInput)
	{
		//IL_001d: 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)
		if (!((Object)(object)characterInput == (Object)null))
		{
			int instanceID = ((Object)characterInput).GetInstanceID();
			CapturedMovementInputs[instanceID] = Vector2.ClampMagnitude(characterInput.movementInput, 1f);
			CapturedShiftInputs[instanceID] = characterInput.sprintIsPressed;
		}
	}

	private static Vector2 GetMovementInput(Character character)
	{
		//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_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_0053: 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_005e: 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_0051: 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)character == (Object)null || (Object)(object)character.input == (Object)null)
		{
			return Vector2.zero;
		}
		Vector2 val = character.input.movementInput;
		if (CapturedMovementInputs.TryGetValue(((Object)character.input).GetInstanceID(), out var value))
		{
			val = value;
		}
		return Vector2.ClampMagnitude(val, 1f);
	}

	private static bool GetShiftHeld(Character character)
	{
		if ((Object)(object)character == (Object)null || (Object)(object)character.input == (Object)null)
		{
			return false;
		}
		if (CapturedShiftInputs.TryGetValue(((Object)character.input).GetInstanceID(), out var value))
		{
			return value;
		}
		return character.input.sprintIsPressed;
	}

	private static bool IsFallOrSleepState(Character character)
	{
		if ((Object)(object)character == (Object)null || (Object)(object)character.data == (Object)null)
		{
			return true;
		}
		if (character.data.dead)
		{
			return true;
		}
		if (character.data.fullyPassedOut)
		{
			return true;
		}
		if (character.data.passedOut)
		{
			return true;
		}
		if (character.data.passedOutOnTheBeach > 0f)
		{
			return true;
		}
		if (character.data.fallSeconds > 0.01f)
		{
			return true;
		}
		if (character.data.currentRagdollControll < 0.9f)
		{
			return true;
		}
		if (character.data.GetTargetRagdollControll() < 0.9f)
		{
			return true;
		}
		return false;
	}

	private static void UpdateStandRecovery(Character character)
	{
		if ((Object)(object)character == (Object)null || !character.IsLocal || (Object)(object)character.data == (Object)null)
		{
			return;
		}
		int instanceID = ((Object)character).GetInstanceID();
		if (IsAirportScene())
		{
			StandRecoveryStates.Remove(instanceID);
			return;
		}
		bool flag = IsFallOrSleepState(character);
		if (!StandRecoveryStates.TryGetValue(instanceID, out var value))
		{
			if (!flag)
			{
				return;
			}
			value = new StandRecoveryState();
			StandRecoveryStates.Add(instanceID, value);
		}
		if (flag)
		{
			value.WaitingForStand = true;
			value.StableSince = -1f;
			return;
		}
		if (!value.WaitingForStand)
		{
			StandRecoveryStates.Remove(instanceID);
			return;
		}
		if (value.StableSince < 0f)
		{
			value.StableSince = Time.time;
			return;
		}
		float num = Time.time - value.StableSince;
		if (!(num < 0.35f))
		{
			StandRecoveryStates.Remove(instanceID);
		}
	}

	private static bool ShouldBlockJump(Character character)
	{
		if ((Object)(object)character == (Object)null || !character.IsLocal || (Object)(object)character.data == (Object)null)
		{
			return false;
		}
		if (IsAirportScene())
		{
			StandRecoveryStates.Remove(((Object)character).GetInstanceID());
			return false;
		}
		UpdateStandRecovery(character);
		if (IsFallOrSleepState(character))
		{
			return true;
		}
		if (!StandRecoveryStates.TryGetValue(((Object)character).GetInstanceID(), out var value))
		{
			return false;
		}
		if (!value.WaitingForStand)
		{
			return false;
		}
		if (value.StableSince < 0f)
		{
			return true;
		}
		float num = Time.time - value.StableSince;
		if (num < 0.35f)
		{
			return true;
		}
		StandRecoveryStates.Remove(((Object)character).GetInstanceID());
		return false;
	}
}
[BepInPlugin("Sapphire009.JumpSound", "JumpSound", "1.0.1")]
public sealed class JumpSound : BaseUnityPlugin
{
	[HarmonyPatch(typeof(CharacterMovement), "JumpRpc", new Type[] { typeof(bool) })]
	private static class CharacterMovementJumpRpcPatch
	{
		private sealed class JumpSoundState
		{
			public Character Character;

			public int JumpsRemainingBefore;

			public bool ChargingJumpBefore;

			public bool IsPalJump;

			public bool Valid;
		}

		[HarmonyPrefix]
		[HarmonyPriority(800)]
		[HarmonyBefore(new string[] { "Sapphire009.JumpingPEAK", "Sapphire009.BeforeStart" })]
		private static void Prefix(CharacterMovement __instance, bool __0, out JumpSoundState __state)
		{
			__state = new JumpSoundState();
			Character val = ResolveCharacter((Component)(object)__instance);
			if (!((Object)(object)val == (Object)null) && !((Object)(object)val.data == (Object)null))
			{
				__state.Character = val;
				__state.JumpsRemainingBefore = val.data.jumpsRemaining;
				__state.ChargingJumpBefore = val.data.chargingJump;
				__state.IsPalJump = __0;
				__state.Valid = true;
			}
		}

		[HarmonyPostfix]
		[HarmonyPriority(0)]
		private static void Postfix(JumpSoundState __state)
		{
			if (__state != null && __state.Valid && !__state.IsPalJump && !((Object)(object)__state.Character == (Object)null) && !((Object)(object)__state.Character.data == (Object)null))
			{
				Character character = __state.Character;
				bool flag = character.data.jumpsRemaining < __state.JumpsRemainingBefore;
				bool flag2 = !__state.ChargingJumpBefore && character.data.chargingJump;
				if (flag || flag2)
				{
					PlayJumpSound(character);
				}
			}
		}
	}

	public const string PluginGUID = "Sapphire009.JumpSound";

	public const string PluginName = "JumpSound";

	public const string PluginVersion = "1.0.1";

	private const float SoundSearchInterval = 1f;

	private const int MinimumSoundScore = 80;

	private static SFX_Instance sourceBounceSound;

	private static SFX_Instance runtimeJumpSound;

	private static float nextSoundSearchTime;

	private Harmony harmony;

	private void Awake()
	{
		//IL_0007: Unknown result type (might be due to invalid IL or missing references)
		//IL_0011: Expected O, but got Unknown
		harmony = new Harmony("Sapphire009.JumpSound");
		harmony.PatchAll();
		SceneManager.sceneLoaded += OnSceneLoaded;
		TryFindBounceShroomSound();
	}

	private void Update()
	{
		if (!((Object)(object)runtimeJumpSound != (Object)null) && !(Time.unscaledTime < nextSoundSearchTime))
		{
			nextSoundSearchTime = Time.unscaledTime + 1f;
			TryFindBounceShroomSound();
		}
	}

	private void OnDestroy()
	{
		SceneManager.sceneLoaded -= OnSceneLoaded;
		DestroyRuntimeSound();
		sourceBounceSound = null;
		if (harmony != null)
		{
			harmony.UnpatchSelf();
			harmony = null;
		}
	}

	private static void OnSceneLoaded(Scene scene, LoadSceneMode loadSceneMode)
	{
		nextSoundSearchTime = 0f;
		if ((Object)(object)runtimeJumpSound == (Object)null)
		{
			TryFindBounceShroomSound();
		}
	}

	internal static bool IsAirportScene()
	{
		//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)
		Scene activeScene = SceneManager.GetActiveScene();
		string name = ((Scene)(ref activeScene)).name;
		if (string.IsNullOrEmpty(name))
		{
			return false;
		}
		return name.IndexOf("Airport", StringComparison.OrdinalIgnoreCase) >= 0;
	}

	private static Character ResolveCharacter(Component component)
	{
		if ((Object)(object)component == (Object)null)
		{
			return null;
		}
		Character val = component.GetComponent<Character>();
		if ((Object)(object)val == (Object)null)
		{
			val = component.GetComponentInParent<Character>();
		}
		return val;
	}

	private static bool TryFindBounceShroomSound()
	{
		if (IsValidSound(runtimeJumpSound))
		{
			return true;
		}
		SFX_Instance val = null;
		int num = int.MinValue;
		CollisionModifier[] array = Resources.FindObjectsOfTypeAll<CollisionModifier>();
		if (array != null)
		{
			foreach (CollisionModifier val2 in array)
			{
				if (!((Object)(object)val2 == (Object)null) && IsValidSound(val2.bounceSFX))
				{
					string hierarchyText = GetHierarchyText(((Component)val2).transform);
					string soundText = GetSoundText(val2.bounceSFX);
					int num2 = ScoreBounceShroomText(hierarchyText);
					num2 += ScoreBounceShroomText(soundText);
					if (val2.knockback > 0f)
					{
						num2 += 10;
					}
					if (num2 > num)
					{
						num = num2;
						val = val2.bounceSFX;
					}
				}
			}
		}
		if ((Object)(object)val == (Object)null || num < 80)
		{
			SFX_Instance[] array2 = Resources.FindObjectsOfTypeAll<SFX_Instance>();
			if (array2 != null)
			{
				foreach (SFX_Instance val3 in array2)
				{
					if (IsValidSound(val3))
					{
						string soundText2 = GetSoundText(val3);
						int num3 = ScoreBounceShroomText(soundText2);
						if (num3 > num)
						{
							num = num3;
							val = val3;
						}
					}
				}
			}
		}
		if ((Object)(object)val == (Object)null || num < 80)
		{
			return false;
		}
		SetBounceShroomSound(val);
		return (Object)(object)runtimeJumpSound != (Object)null;
	}

	private static void SetBounceShroomSound(SFX_Instance sound)
	{
		if (IsValidSound(sound) && (!((Object)(object)sourceBounceSound == (Object)(object)sound) || !IsValidSound(runtimeJumpSound)))
		{
			DestroyRuntimeSound();
			sourceBounceSound = sound;
			runtimeJumpSound = Object.Instantiate<SFX_Instance>(sourceBounceSound);
			if (!((Object)(object)runtimeJumpSound == (Object)null))
			{
				((Object)runtimeJumpSound).name = "Sapphire009_JumpSound_BounceShroom";
				((Object)runtimeJumpSound).hideFlags = (HideFlags)61;
			}
		}
	}

	private static void DestroyRuntimeSound()
	{
		if (!((Object)(object)runtimeJumpSound == (Object)null))
		{
			Object.Destroy((Object)(object)runtimeJumpSound);
			runtimeJumpSound = null;
		}
	}

	private static bool IsValidSound(SFX_Instance sound)
	{
		return (Object)(object)sound != (Object)null && sound.clips != null && sound.clips.Length != 0;
	}

	private static string GetHierarchyText(Transform transform)
	{
		if ((Object)(object)transform == (Object)null)
		{
			return string.Empty;
		}
		string text = string.Empty;
		Transform val = transform;
		int num = 0;
		while ((Object)(object)val != (Object)null && num < 8)
		{
			text = (string.IsNullOrEmpty(text) ? ((Object)val).name : (((Object)val).name + "/" + text));
			val = val.parent;
			num++;
		}
		return text;
	}

	private static string GetSoundText(SFX_Instance sound)
	{
		if ((Object)(object)sound == (Object)null)
		{
			return string.Empty;
		}
		string text = ((Object)sound).name;
		if (sound.clips == null)
		{
			return text;
		}
		for (int i = 0; i < sound.clips.Length; i++)
		{
			AudioClip val = sound.clips[i];
			if (!((Object)(object)val == (Object)null))
			{
				text = text + "/" + ((Object)val).name;
			}
		}
		return text;
	}

	private static int ScoreBounceShroomText(string text)
	{
		if (string.IsNullOrEmpty(text))
		{
			return 0;
		}
		string source = text.ToLowerInvariant();
		int num = 0;
		if (Contains(source, "bounceshroom"))
		{
			num += 200;
		}
		if (Contains(source, "bounce shroom"))
		{
			num += 200;
		}
		if (Contains(source, "bounce_shroom"))
		{
			num += 200;
		}
		if (Contains(source, "shroombounce"))
		{
			num += 180;
		}
		if (Contains(source, "shroom bounce"))
		{
			num += 180;
		}
		if (Contains(source, "mushroom bounce"))
		{
			num += 170;
		}
		if (Contains(source, "bounce mushroom"))
		{
			num += 170;
		}
		if (Contains(source, "bounce"))
		{
			num += 25;
		}
		if (Contains(source, "shroom"))
		{
			num += 80;
		}
		if (Contains(source, "mushroom"))
		{
			num += 70;
		}
		if (Contains(source, "fungus"))
		{
			num += 50;
		}
		return num;
	}

	private static bool Contains(string source, string value)
	{
		return source.IndexOf(value, StringComparison.OrdinalIgnoreCase) >= 0;
	}

	private static void PlayJumpSound(Character character)
	{
		//IL_005e: Unknown result type (might be due to invalid IL or missing references)
		if (!((Object)(object)character == (Object)null) && !IsAirportScene())
		{
			if (!IsValidSound(runtimeJumpSound))
			{
				TryFindBounceShroomSound();
			}
			if (IsValidSound(runtimeJumpSound) && !((Object)(object)SFX_Player.instance == (Object)null))
			{
				SFX_Player.instance.PlaySFX(runtimeJumpSound, character.Center, (Transform)null, (SFX_Settings)null, 1f, false);
			}
		}
	}
}
[BepInPlugin("Sapphire009.Runup", "Runup", "1.0.1")]
public sealed class Runup : BaseUnityPlugin
{
	[HarmonyPatch(typeof(CharacterMovement), "Start")]
	private static class CharacterMovementStartPatch
	{
		[HarmonyPostfix]
		private static void Postfix(CharacterMovement __instance)
		{
			StoreOriginalJumpImpulse(__instance, overwrite: true);
		}
	}

	[HarmonyPatch(typeof(CharacterMovement), "JumpRpc", new Type[] { typeof(bool) })]
	private static class CharacterMovementJumpRpcPatch
	{
		private sealed class PalJumpPatchState
		{
			public bool Applied;

			public Character Character;

			public float OriginalJumpImpulse;

			public float PreviousSincePalJump;

			public int RestoreToken;
		}

		[HarmonyPrefix]
		[HarmonyPriority(0)]
		[HarmonyAfter(new string[] { "Sapphire009.JumpingPEAK" })]
		private static void Prefix(CharacterMovement __instance, bool __0, out PalJumpPatchState __state)
		{
			__state = new PalJumpPatchState();
			if (__0 && !((Object)(object)__instance == (Object)null))
			{
				Character val = ResolveCharacter((Component)(object)__instance);
				if (!((Object)(object)val == (Object)null) && val.IsLocal && !((Object)(object)val.data == (Object)null) && !IsAirportScene() && !val.data.dead && !val.data.fullyPassedOut && TryGetOriginalJumpImpulse(__instance, out var originalJumpImpulse))
				{
					float jumpImpulse = originalJumpImpulse * 10.416666f;
					int restoreToken = CreateRestoreToken(__instance);
					__state.Applied = true;
					__state.Character = val;
					__state.OriginalJumpImpulse = originalJumpImpulse;
					__state.PreviousSincePalJump = val.data.sincePalJump;
					__state.RestoreToken = restoreToken;
					__instance.jumpImpulse = jumpImpulse;
				}
			}
		}

		[HarmonyPostfix]
		[HarmonyPriority(0)]
		[HarmonyAfter(new string[] { "Sapphire009.JumpingPEAK" })]
		private static void Postfix(CharacterMovement __instance, PalJumpPatchState __state)
		{
			if (!((Object)(object)__instance == (Object)null) && __state != null && __state.Applied && !((Object)(object)__state.Character == (Object)null))
			{
				((MonoBehaviour)__instance).StartCoroutine(RestoreAfterPalJump(__instance, __state.Character, __state.OriginalJumpImpulse, __state.PreviousSincePalJump, __state.RestoreToken));
			}
		}
	}

	public const string PluginGUID = "Sapphire009.Runup";

	public const string PluginName = "Runup";

	public const string PluginVersion = "1.0.1";

	private const float JumpingPeakJumpMultiplier = 5f;

	private const float RunupRelativeMultiplier = 4.1666665f;

	private const float NativePalJumpMultiplier = 2f;

	private const float RunupImpulseMultiplier = 10.416666f;

	private const int MaximumRestoreWaitFrames = 120;

	private const int RestoreSafetyFrames = 4;

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

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

	private static readonly WaitForFixedUpdate WaitForPhysics = new WaitForFixedUpdate();

	private static int nextRestoreToken;

	private Harmony harmony;

	private void Awake()
	{
		//IL_0007: Unknown result type (might be due to invalid IL or missing references)
		//IL_0011: Expected O, but got Unknown
		harmony = new Harmony("Sapphire009.Runup");
		harmony.PatchAll();
	}

	private void OnDestroy()
	{
		OriginalJumpImpulses.Clear();
		ActiveRestoreTokens.Clear();
		nextRestoreToken = 0;
		if (harmony != null)
		{
			harmony.UnpatchSelf();
			harmony = null;
		}
	}

	internal static bool IsAirportScene()
	{
		//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)
		Scene activeScene = SceneManager.GetActiveScene();
		string name = ((Scene)(ref activeScene)).name;
		if (string.IsNullOrEmpty(name))
		{
			return false;
		}
		return name.IndexOf("Airport", StringComparison.OrdinalIgnoreCase) >= 0;
	}

	private static Character ResolveCharacter(Component component)
	{
		if ((Object)(object)component == (Object)null)
		{
			return null;
		}
		Character val = component.GetComponent<Character>();
		if ((Object)(object)val == (Object)null)
		{
			val = component.GetComponentInParent<Character>();
		}
		return val;
	}

	private static void StoreOriginalJumpImpulse(CharacterMovement movement, bool overwrite)
	{
		if ((Object)(object)movement == (Object)null)
		{
			return;
		}
		float jumpImpulse = movement.jumpImpulse;
		if (!(jumpImpulse <= 0f))
		{
			int instanceID = ((Object)movement).GetInstanceID();
			if (overwrite || !OriginalJumpImpulses.ContainsKey(instanceID))
			{
				OriginalJumpImpulses[instanceID] = jumpImpulse;
			}
		}
	}

	private static bool TryGetOriginalJumpImpulse(CharacterMovement movement, out float originalJumpImpulse)
	{
		originalJumpImpulse = 0f;
		if ((Object)(object)movement == (Object)null)
		{
			return false;
		}
		int instanceID = ((Object)movement).GetInstanceID();
		if (OriginalJumpImpulses.TryGetValue(instanceID, out originalJumpImpulse))
		{
			return originalJumpImpulse > 0f;
		}
		StoreOriginalJumpImpulse(movement, overwrite: false);
		return OriginalJumpImpulses.TryGetValue(instanceID, out originalJumpImpulse) && originalJumpImpulse > 0f;
	}

	private static int CreateRestoreToken(CharacterMovement movement)
	{
		nextRestoreToken++;
		if (nextRestoreToken <= 0)
		{
			nextRestoreToken = 1;
		}
		int instanceID = ((Object)movement).GetInstanceID();
		ActiveRestoreTokens[instanceID] = nextRestoreToken;
		return nextRestoreToken;
	}

	private static bool IsCurrentRestoreToken(CharacterMovement movement, int restoreToken)
	{
		if ((Object)(object)movement == (Object)null)
		{
			return false;
		}
		int value;
		return ActiveRestoreTokens.TryGetValue(((Object)movement).GetInstanceID(), out value) && value == restoreToken;
	}

	private static void RestoreOriginalJumpImpulse(CharacterMovement movement, float originalJumpImpulse, int restoreToken)
	{
		if (IsCurrentRestoreToken(movement, restoreToken))
		{
			int instanceID = ((Object)movement).GetInstanceID();
			if (originalJumpImpulse > 0f)
			{
				movement.jumpImpulse = originalJumpImpulse;
			}
			ActiveRestoreTokens.Remove(instanceID);
		}
	}

	private static IEnumerator RestoreAfterPalJump(CharacterMovement movement, Character character, float originalJumpImpulse, float previousSincePalJump, int restoreToken)
	{
		if ((Object)(object)movement == (Object)null || (Object)(object)character == (Object)null || (Object)(object)character.data == (Object)null)
		{
			RestoreOriginalJumpImpulse(movement, originalJumpImpulse, restoreToken);
			yield break;
		}
		bool palJumpStarted = false;
		for (int frame = 0; frame < 120; frame++)
		{
			if (!IsCurrentRestoreToken(movement, restoreToken))
			{
				yield break;
			}
			if ((Object)(object)movement == (Object)null || (Object)(object)character == (Object)null || (Object)(object)character.data == (Object)null)
			{
				RestoreOriginalJumpImpulse(movement, originalJumpImpulse, restoreToken);
				yield break;
			}
			if (character.data.dead || character.data.fullyPassedOut)
			{
				RestoreOriginalJumpImpulse(movement, originalJumpImpulse, restoreToken);
				yield break;
			}
			bool sincePalJumpWasReset = character.data.sincePalJump < previousSincePalJump - 0.0001f;
			if (character.data.chargingJump || sincePalJumpWasReset)
			{
				palJumpStarted = true;
				break;
			}
			yield return WaitForPhysics;
		}
		if (!palJumpStarted)
		{
			RestoreOriginalJumpImpulse(movement, originalJumpImpulse, restoreToken);
			yield break;
		}
		for (int i = 0; i < 120; i++)
		{
			yield return WaitForPhysics;
			if (!IsCurrentRestoreToken(movement, restoreToken))
			{
				yield break;
			}
			if ((Object)(object)movement == (Object)null || (Object)(object)character == (Object)null || (Object)(object)character.data == (Object)null)
			{
				RestoreOriginalJumpImpulse(movement, originalJumpImpulse, restoreToken);
				yield break;
			}
			if (character.data.chargingJump)
			{
				continue;
			}
			for (int safetyFrame = 0; safetyFrame < 4; safetyFrame++)
			{
				yield return WaitForPhysics;
				if (!IsCurrentRestoreToken(movement, restoreToken))
				{
					yield break;
				}
			}
			RestoreOriginalJumpImpulse(movement, originalJumpImpulse, restoreToken);
			yield break;
		}
		RestoreOriginalJumpImpulse(movement, originalJumpImpulse, restoreToken);
	}
}
[BepInPlugin("Sapphire009.StaminaFull", "StaminaFull", "1.0.2")]
public sealed class StaminaFull : BaseUnityPlugin
{
	[HarmonyPatch(typeof(Character), "UseStamina", new Type[]
	{
		typeof(float),
		typeof(bool),
		typeof(bool)
	})]
	private static class CharacterUseStaminaPatch
	{
		[HarmonyPrefix]
		private static bool Prefix(Character __instance, float __0, bool __1, bool __2, ref bool __result)
		{
			if (__0 <= 0f)
			{
				return true;
			}
			if (!CanApplyProtection(__instance))
			{
				return true;
			}
			FillAndPreserveStamina(__instance);
			__instance.data.sinceUseStamina = 0f;
			__result = true;
			return false;
		}
	}

	[HarmonyPatch(typeof(Character), "AddStamina", new Type[] { typeof(float) })]
	private static class CharacterAddStaminaPatch
	{
		[HarmonyPrefix]
		private static bool Prefix(Character __instance, float __0)
		{
			if (__0 >= 0f)
			{
				return true;
			}
			return !CanApplyProtection(__instance);
		}
	}

	[HarmonyPatch(typeof(Character), "SetExtraStamina", new Type[] { typeof(float) })]
	private static class CharacterSetExtraStaminaPatch
	{
		[HarmonyPrefix]
		private static bool Prefix(Character __instance, float __0)
		{
			if (!CanApplyProtection(__instance))
			{
				return true;
			}
			if (__0 >= __instance.data.extraStamina)
			{
				return true;
			}
			return false;
		}
	}

	[HarmonyPatch(typeof(Character), "AddExtraStamina", new Type[] { typeof(float) })]
	private static class CharacterAddExtraStaminaPatch
	{
		[HarmonyPrefix]
		private static bool Prefix(Character __instance, float __0)
		{
			if (__0 >= 0f)
			{
				return true;
			}
			return !CanApplyProtection(__instance);
		}
	}

	[HarmonyPatch(typeof(CharacterAfflictions), "AddStatus", new Type[]
	{
		typeof(STATUSTYPE),
		typeof(float),
		typeof(bool),
		typeof(bool),
		typeof(bool)
	})]
	private static class CharacterAfflictionsAddStatusPatch
	{
		[HarmonyPrefix]
		private static bool Prefix(CharacterAfflictions __instance, STATUSTYPE __0, float __1, bool __2, bool __3, bool __4, ref bool __result)
		{
			if (__1 <= 0f || !CanApplyProtection(__instance))
			{
				return true;
			}
			__result = false;
			return false;
		}
	}

	[HarmonyPatch(typeof(CharacterAfflictions), "AdjustStatus", new Type[]
	{
		typeof(STATUSTYPE),
		typeof(float),
		typeof(bool)
	})]
	private static class CharacterAfflictionsAdjustStatusPatch
	{
		[HarmonyPrefix]
		private static bool Prefix(CharacterAfflictions __instance, STATUSTYPE __0, float __1, bool __2)
		{
			if (__1 <= 0f || !CanApplyProtection(__instance))
			{
				return true;
			}
			return false;
		}
	}

	[HarmonyPatch(typeof(CharacterAfflictions), "SetStatus", new Type[]
	{
		typeof(STATUSTYPE),
		typeof(float),
		typeof(bool)
	})]
	private static class CharacterAfflictionsSetStatusPatch
	{
		[HarmonyPrefix]
		private static bool Prefix(CharacterAfflictions __instance, STATUSTYPE __0, float __1, bool __2)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: 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)
			if (!CanApplyProtection(__instance))
			{
				return true;
			}
			float currentStatus = __instance.GetCurrentStatus(__0);
			if (__1 <= currentStatus)
			{
				return true;
			}
			return false;
		}
	}

	[HarmonyPatch(typeof(CharacterAfflictions), "AddAffliction", new Type[]
	{
		typeof(Affliction),
		typeof(bool)
	})]
	private static class CharacterAfflictionsAddAfflictionPatch
	{
		[HarmonyPrefix]
		private static bool Prefix(CharacterAfflictions __instance, Affliction __0, bool __1)
		{
			if (!CanApplyProtection(__instance))
			{
				return true;
			}
			return false;
		}
	}

	[HarmonyPatch(typeof(CharacterAfflictions), "AddThorn", new Type[]
	{
		typeof(Vector3),
		typeof(int)
	})]
	private static class CharacterAfflictionsAddThornPositionPatch
	{
		[HarmonyPrefix]
		private static bool Prefix(CharacterAfflictions __instance, Vector3 __0, int __1)
		{
			if (!CanApplyProtection(__instance))
			{
				return true;
			}
			return false;
		}
	}

	[HarmonyPatch(typeof(CharacterAfflictions), "AddThorn", new Type[]
	{
		typeof(int),
		typeof(ushort),
		typeof(bool)
	})]
	private static class CharacterAfflictionsAddThornIndexPatch
	{
		[HarmonyPrefix]
		private static bool Prefix(CharacterAfflictions __instance, int __0, ushort __1, bool __2)
		{
			if (!CanApplyProtection(__instance))
			{
				return true;
			}
			return false;
		}
	}

	[HarmonyPatch(typeof(CharacterAfflictions), "RPC_EnableThorn", new Type[] { typeof(int) })]
	private static class CharacterAfflictionsEnableThornPatch
	{
		[HarmonyPrefix]
		private static bool Prefix(CharacterAfflictions __instance, int __0)
		{
			if (!CanApplyProtection(__instance))
			{
				return true;
			}
			return false;
		}
	}

	[HarmonyPatch(typeof(Character), "FixedUpdate")]
	private static class CharacterFixedUpdatePatch
	{
		[HarmonyPostfix]
		private static void Postfix(Character __instance)
		{
			if (!CanApplyProtection(__instance))
			{
				if ((Object)(object)__instance != (Object)null)
				{
					PreservedExtraStamina.Remove(((Object)__instance).GetInstanceID());
				}
			}
			else
			{
				ClearAllNegativeStates(__instance);
				FillAndPreserveStamina(__instance);
			}
		}
	}

	public const string PluginGUID = "Sapphire009.StaminaFull";

	public const string PluginName = "StaminaFull";

	public const string PluginVersion = "1.0.2";

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

	private Harmony harmony;

	private void Awake()
	{
		//IL_0007: Unknown result type (might be due to invalid IL or missing references)
		//IL_0011: Expected O, but got Unknown
		harmony = new Harmony("Sapphire009.StaminaFull");
		harmony.PatchAll();
	}

	private void OnDestroy()
	{
		PreservedExtraStamina.Clear();
		if (harmony != null)
		{
			harmony.UnpatchSelf();
			harmony = null;
		}
	}

	internal static bool IsAirportScene()
	{
		//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)
		Scene activeScene = SceneManager.GetActiveScene();
		string name = ((Scene)(ref activeScene)).name;
		if (string.IsNullOrEmpty(name))
		{
			return false;
		}
		return name.IndexOf("Airport", StringComparison.OrdinalIgnoreCase) >= 0;
	}

	internal static bool CanApplyProtection(Character character)
	{
		if ((Object)(object)character == (Object)null || !character.IsLocal || (Object)(object)character.data == (Object)null || character.refs == null || (Object)(object)character.refs.afflictions == (Object)null)
		{
			return false;
		}
		if (IsAirportScene())
		{
			return false;
		}
		return true;
	}

	internal static bool CanApplyProtection(CharacterAfflictions afflictions)
	{
		if ((Object)(object)afflictions == (Object)null)
		{
			return false;
		}
		return CanApplyProtection(afflictions.character);
	}

	internal static void FillAndPreserveStamina(Character character)
	{
		if (!CanApplyProtection(character))
		{
			if ((Object)(object)character != (Object)null)
			{
				PreservedExtraStamina.Remove(((Object)character).GetInstanceID());
			}
			return;
		}
		float maxStamina = character.GetMaxStamina();
		maxStamina = Mathf.Max(maxStamina, 1f);
		bool flag = false;
		if (Mathf.Abs(character.data.currentStamina - maxStamina) > 0.0001f)
		{
			character.data.currentStamina = maxStamina;
			flag = true;
		}
		int instanceID = ((Object)character).GetInstanceID();
		if (!PreservedExtraStamina.TryGetValue(instanceID, out var value))
		{
			value = character.data.extraStamina;
			PreservedExtraStamina.Add(instanceID, value);
		}
		else if (character.data.extraStamina > value)
		{
			value = character.data.extraStamina;
			PreservedExtraStamina[instanceID] = value;
		}
		else if (character.data.extraStamina < value)
		{
			character.data.extraStamina = value;
			flag = true;
		}
		if (flag && (Object)(object)GUIManager.instance != (Object)null && (Object)(object)GUIManager.instance.bar != (Object)null)
		{
			GUIManager.instance.bar.ChangeBar();
		}
	}

	internal static void ClearAllNegativeStates(Character character)
	{
		//IL_0030: 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_004e: Unknown result type (might be due to invalid IL or missing references)
		if (!CanApplyProtection(character))
		{
			return;
		}
		CharacterAfflictions afflictions = character.refs.afflictions;
		bool flag = false;
		int numStatusTypes = CharacterAfflictions.NumStatusTypes;
		for (int i = 0; i < numStatusTypes; i++)
		{
			STATUSTYPE val = (STATUSTYPE)i;
			if (!(afflictions.GetCurrentStatus(val) <= 0f))
			{
				afflictions.SetStatus(val, 0f, false);
				flag = true;
			}
		}
		if (afflictions.isWebbed)
		{
			afflictions.SetStatus((STATUSTYPE)11, 0f, false);
			afflictions.isWebbed = false;
			flag = true;
		}
		if (flag)
		{
			afflictions.PushStatuses((Player)null);
		}
		if (afflictions.afflictionList != null && afflictions.afflictionList.Count > 0)
		{
			afflictions.ClearAllAfflictions();
		}
		if (afflictions.physicalThorns == null)
		{
			return;
		}
		for (int num = afflictions.physicalThorns.Count - 1; num >= 0; num--)
		{
			ThornOnMe val2 = afflictions.physicalThorns[num];
			if (!((Object)(object)val2 == (Object)null) && val2.stuckIn)
			{
				afflictions.RemoveThorn(val2, false);
			}
		}
	}
}
[BepInPlugin("Sapphire009.WASDX", "WASDX", "1.0.1")]
public sealed class WASDX : BaseUnityPlugin
{
	[HarmonyPatch(typeof(CharacterInput), "Sample", new Type[] { typeof(bool) })]
	private static class CharacterInputSamplePatch
	{
		[HarmonyPostfix]
		private static void Postfix(CharacterInput __instance)
		{
			//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_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_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_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)
			if ((Object)(object)__instance == (Object)null)
			{
				GroundLeanInput = Vector2.zero;
				return;
			}
			Character val = ResolveCharacter((Component)(object)__instance);
			if (!((Object)(object)val == (Object)null) && val.IsLocal && !((Object)(object)val.data == (Object)null))
			{
				if (!ShouldBlockGroundMovement(val))
				{
					GroundLeanInput = Vector2.zero;
					return;
				}
				GroundLeanInput = __instance.movementInput;
				__instance.movementInput = Vector2.zero;
			}
		}
	}

	[HarmonyPatch(typeof(CharacterMovement), "GetMovementForce")]
	private static class CharacterMovementGetMovementForcePatch
	{
		[HarmonyPostfix]
		private static void Postfix(CharacterMovement __instance, ref float __result)
		{
			Character character = ResolveCharacter((Component)(object)__instance);
			if (ShouldBlockGroundMovement(character))
			{
				__result = 0f;
			}
		}
	}

	[HarmonyPatch(typeof(MainCameraMovement), "CharacterCam")]
	private static class MainCameraMovementCharacterCamPatch
	{
		private const float ForwardTiltDegrees = 4f;

		private const float SideTiltDegrees = 4f;

		private const float TiltSmoothSpeed = 9f;

		private static Vector2 currentTilt = Vector2.zero;

		[HarmonyPostfix]
		private static void Postfix(MainCameraMovement __instance)
		{
			//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_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_0052: 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_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: 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_00be: 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_00c5: 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)
			if (!((Object)(object)__instance == (Object)null))
			{
				Character localCharacter = Character.localCharacter;
				Vector2 val = Vector2.zero;
				if (ShouldBlockGroundMovement(localCharacter))
				{
					val = GroundLeanInput;
				}
				float num = 1f - Mathf.Exp(-9f * Time.deltaTime);
				currentTilt = Vector2.Lerp(currentTilt, val, num);
				if (((Vector2)(ref currentTilt)).sqrMagnitude < 1E-06f)
				{
					currentTilt = Vector2.zero;
				}
				float num2 = currentTilt.y * 4f;
				float num3 = (0f - currentTilt.x) * 4f;
				Quaternion val2 = Quaternion.Euler(num2, 0f, num3);
				((Component)__instance).transform.rotation = ((Component)__instance).transform.rotation * val2;
			}
		}

		internal static void ResetTilt()
		{
			//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)
			currentTilt = Vector2.zero;
		}
	}

	public const string PluginGUID = "Sapphire009.WASDX";

	public const string PluginName = "WASDX";

	public const string PluginVersion = "1.0.1";

	internal static Vector2 GroundLeanInput = Vector2.zero;

	private Harmony harmony;

	private void Awake()
	{
		//IL_0007: Unknown result type (might be due to invalid IL or missing references)
		//IL_0011: Expected O, but got Unknown
		harmony = new Harmony("Sapphire009.WASDX");
		harmony.PatchAll();
	}

	private void OnDestroy()
	{
		//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)
		GroundLeanInput = Vector2.zero;
		MainCameraMovementCharacterCamPatch.ResetTilt();
		if (harmony != null)
		{
			harmony.UnpatchSelf();
			harmony = null;
		}
	}

	internal static bool IsAirportScene()
	{
		//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)
		Scene activeScene = SceneManager.GetActiveScene();
		string name = ((Scene)(ref activeScene)).name;
		if (string.IsNullOrEmpty(name))
		{
			return false;
		}
		return name.IndexOf("Airport", StringComparison.OrdinalIgnoreCase) >= 0;
	}

	internal static Character ResolveCharacter(Component component)
	{
		if ((Object)(object)component == (Object)null)
		{
			return null;
		}
		Character val = component.GetComponent<Character>();
		if ((Object)(object)val == (Object)null)
		{
			val = component.GetComponentInParent<Character>();
		}
		return val;
	}

	internal static bool ShouldBlockGroundMovement(Character character)
	{
		if ((Object)(object)character == (Object)null || !character.IsLocal || (Object)(object)character.data == (Object)null)
		{
			return false;
		}
		if (IsAirportScene())
		{
			return false;
		}
		return character.data.isGrounded;
	}
}