using System;
using System.Collections;
using System.Diagnostics;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Threading.Tasks;
using BepInEx;
using GameNetcodeStuff;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Unity.Netcode;
using UnityEngine;
using UnityEngine.InputSystem;
using UnityEngine.Networking;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("SlidingCompany")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyDescription("A Lethal Company mod that allows the player to crouch-slide.")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("SlidingCompany")]
[assembly: AssemblyTitle("SlidingCompany")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.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 SlidingCompany
{
	public class PlayerSlideController : MonoBehaviour
	{
		public PlayerControllerB playerController;

		public float slideSpeed;

		public float initialSlideSpeedBoost = 15f;

		public float slideFriction = 0.1f;

		public float friction = 0.97f;

		public float airFriction = 0.99f;

		public float maxSlideAngleChange = 30f;

		private const float gravity = 50f;

		private const float initialSlideStaminaCost = 0.08f;

		private const float carriedItemWeightMultiplier = 2f;

		private const float slideStaminaDrain = 0f;

		private const float stopSlideSpeed = 0.5f;

		private bool isSliding;

		private bool isCrouching;

		private PhysicMaterial originalMaterial;

		private PhysicMaterial slideMaterial;

		private Vector3 lastSlideDirection = Vector3.zero;

		private AudioSource slidingAudio;

		private static async Task<AudioClip> GetAudioClip(string filePath, AudioType fileType)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			UnityWebRequest www = UnityWebRequestMultimedia.GetAudioClip(filePath, fileType);
			try
			{
				UnityWebRequestAsyncOperation result = www.SendWebRequest();
				while (!((AsyncOperation)result).isDone)
				{
					await Task.Delay(100);
				}
				if ((int)www.result == 2)
				{
					Debug.Log((object)www.error);
					return null;
				}
				return DownloadHandlerAudioClip.GetContent(www);
			}
			finally
			{
				((IDisposable)www)?.Dispose();
			}
		}

		private async void Start()
		{
			originalMaterial = ((Collider)playerController.thisController).material;
			slideMaterial = new PhysicMaterial("PlayerSlideMaterial");
			slideMaterial.staticFriction = slideFriction;
			slideMaterial.dynamicFriction = slideFriction;
			string text = Path.Combine(Paths.PluginPath, "undefined-SlidingCompany", "SlidingCompany", "concrete.wav");
			Debug.Log((object)("Attempting to load concrete audio source at: " + text));
			AudioClip val = await GetAudioClip(text, (AudioType)20);
			if ((Object)(object)val != (Object)null)
			{
				Debug.Log((object)"Loaded concrete audio clip.");
				Debug.Log((object)("Loaded concrete audio data status: " + val.LoadAudioData()));
				slidingAudio = ((Component)playerController.thisController).gameObject.AddComponent<AudioSource>();
				if ((Object)(object)slidingAudio != (Object)null)
				{
					Debug.Log((object)"Successfully attached an AudioSource to player gameobject");
					slidingAudio.clip = val;
					slidingAudio.playOnAwake = false;
					slidingAudio.loop = true;
				}
				else
				{
					Debug.Log((object)"Failed to attach an AudioSource to player gameobject");
				}
			}
			else
			{
				Debug.Log((object)"Failed to load concrete audio clip");
			}
		}

		private void OnSlideStart()
		{
			isSliding = true;
			playerController.playerBodyAnimator.SetBool("Walking", false);
			playerController.playerBodyAnimator.SetBool("Sprinting", false);
			playerController.playerBodyAnimator.SetBool("Jumping", false);
			playerController.playerBodyAnimator.SetBool("crouching", true);
		}

		private void SlideUpdate(Vector3 slideDirection)
		{
			//IL_0098: 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_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			playerController.playerBodyAnimator.SetBool("Walking", false);
			playerController.playerBodyAnimator.SetBool("Sprinting", false);
			playerController.playerBodyAnimator.SetBool("Jumping", false);
			playerController.playerBodyAnimator.SetBool("crouching", true);
			IngamePlayerSettings.Instance.playerInput.actions.FindAction("Sprint", false).Disable();
			((Collider)playerController.thisController).material = slideMaterial;
			playerController.thisController.Move(slideDirection * slideSpeed * Time.fixedDeltaTime);
			playerController.sprintMeter = Mathf.Clamp(playerController.sprintMeter - 0f, 0f, 1f);
		}

		private void UpdateSlideAudio()
		{
			if (!((Object)(object)slidingAudio != (Object)null))
			{
				return;
			}
			if (isSliding)
			{
				if (!slidingAudio.isPlaying)
				{
					slidingAudio.Play();
				}
			}
			else if (slidingAudio.isPlaying)
			{
				slidingAudio.Stop();
			}
		}

		private void OnSlideEnd()
		{
			isSliding = false;
			if ((Object)(object)slidingAudio != (Object)null && slidingAudio.isPlaying)
			{
				slidingAudio.Stop();
			}
			((Collider)playerController.thisController).material = originalMaterial;
			IngamePlayerSettings.Instance.playerInput.actions.FindAction("Sprint", false).Enable();
			FixAnimations();
		}

		private void FixAnimations()
		{
			if (!isSliding)
			{
				bool flag = (bool)typeof(PlayerControllerB).GetField("isJumping", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(playerController);
				bool flag2 = (bool)typeof(PlayerControllerB).GetField("isWalking", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(playerController);
				playerController.playerBodyAnimator.SetBool("Jumping", flag);
				playerController.playerBodyAnimator.SetBool("Walking", flag2);
				playerController.playerBodyAnimator.SetBool("Sprinting", playerController.isSprinting);
				playerController.playerBodyAnimator.SetBool("crouching", playerController.isCrouching);
			}
			else
			{
				playerController.playerBodyAnimator.SetBool("Walking", false);
				playerController.playerBodyAnimator.SetBool("Sprinting", false);
				playerController.playerBodyAnimator.SetBool("Jumping", false);
				playerController.playerBodyAnimator.SetBool("crouching", true);
			}
		}

		private bool ShouldUpdate()
		{
			if ((!((NetworkBehaviour)playerController).IsOwner || !playerController.isPlayerControlled || (((NetworkBehaviour)playerController).IsServer && !playerController.isHostPlayerObject)) && !playerController.isTestingPlayer)
			{
				return false;
			}
			return true;
		}

		private void Update()
		{
			if (playerController.isPlayerDead)
			{
				isSliding = false;
				isCrouching = false;
			}
			UpdateSlideAudio();
			if (ShouldUpdate())
			{
				FixAnimations();
			}
		}

		private float getWeightMultiplier()
		{
			float num = playerController.carryWeight - 1f;
			return 1f + num * 2f;
		}

		private float getFriction()
		{
			if (playerController.thisController.isGrounded)
			{
				return friction;
			}
			return airFriction;
		}

		private void FixedUpdate()
		{
			//IL_00dd: 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_0131: Unknown result type (might be due to invalid IL or missing references)
			//IL_0136: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: 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_0210: Unknown result type (might be due to invalid IL or missing references)
			//IL_021b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0225: Unknown result type (might be due to invalid IL or missing references)
			//IL_022a: Unknown result type (might be due to invalid IL or missing references)
			//IL_025f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0264: Unknown result type (might be due to invalid IL or missing references)
			//IL_027e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0283: Unknown result type (might be due to invalid IL or missing references)
			//IL_0287: Unknown result type (might be due to invalid IL or missing references)
			//IL_028c: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_02cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02db: Unknown result type (might be due to invalid IL or missing references)
			//IL_02df: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0374: Unknown result type (might be due to invalid IL or missing references)
			//IL_033a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0341: Unknown result type (might be due to invalid IL or missing references)
			//IL_0348: Unknown result type (might be due to invalid IL or missing references)
			//IL_034f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0354: Unknown result type (might be due to invalid IL or missing references)
			if (!ShouldUpdate())
			{
				return;
			}
			bool flag = (bool)typeof(PlayerControllerB).GetField("isJumping", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(playerController);
			bool flag2 = isSliding;
			Vector3 val;
			if (!isCrouching)
			{
				isCrouching = playerController.isCrouching;
				int num;
				if (!playerController.isExhausted && !playerController.isPlayerDead && playerController.sprintMeter >= 0.08f * getWeightMultiplier() && isCrouching)
				{
					val = playerController.thisController.velocity;
					num = ((((Vector3)(ref val)).magnitude > 0f) ? 1 : 0);
				}
				else
				{
					num = 0;
				}
				isSliding = (byte)num != 0;
				if (isSliding && playerController.thisController.isGrounded)
				{
					val = playerController.thisController.velocity;
					slideSpeed = ((Vector3)(ref val)).magnitude + initialSlideSpeedBoost / getWeightMultiplier();
					playerController.sprintMeter = Mathf.Clamp(playerController.sprintMeter - 0.08f * getWeightMultiplier(), 0f, 1f);
					lastSlideDirection = Vector3.zero;
				}
				else if (isSliding)
				{
					isCrouching = false;
				}
			}
			else if (!playerController.isCrouching)
			{
				isCrouching = false;
				isSliding = false;
			}
			if (playerController.isPlayerDead || playerController.isClimbingLadder)
			{
				isSliding = false;
				isCrouching = false;
				slideSpeed = 0f;
			}
			if (flag2 && !isSliding)
			{
				OnSlideEnd();
				return;
			}
			if (!flag2 && isSliding)
			{
				OnSlideStart();
			}
			slideSpeed *= getFriction();
			if (Mathf.Abs(slideSpeed) <= 0.5f)
			{
				slideSpeed = 0f;
			}
			if (flag || !playerController.thisController.isGrounded)
			{
				playerController.thisController.Move(lastSlideDirection * slideSpeed * Time.fixedDeltaTime);
			}
			if (!isSliding && !isCrouching)
			{
				OnSlideEnd();
				return;
			}
			UpdateSlideAudio();
			Ray val2 = default(Ray);
			((Ray)(ref val2))..ctor(((Component)playerController.gameplayCamera).transform.position, Vector3.down);
			val = ((Component)playerController.gameplayCamera).transform.forward;
			Vector3 normalized = ((Vector3)(ref val)).normalized;
			if (playerController.thisController.isGrounded && isSliding)
			{
				RaycastHit val3 = default(RaycastHit);
				Physics.Raycast(val2, ref val3, 20f, playerController.playersManager.allPlayersCollideWithMask, (QueryTriggerInteraction)1);
				val = Vector3.ProjectOnPlane(normalized, ((RaycastHit)(ref val3)).normal);
				normalized = ((Vector3)(ref val)).normalized;
				float num2 = 0f - Vector3.Dot(normalized, Vector3.up);
				slideSpeed += num2 * 50f * playerController.carryWeight * Time.fixedDeltaTime;
				if (Mathf.Abs(slideSpeed) <= 0.5f)
				{
					slideSpeed = 0f;
				}
				lastSlideDirection = new Vector3(normalized.x, normalized.y, normalized.z);
			}
			if (isSliding && Mathf.Abs(slideSpeed) >= 0.5f)
			{
				SlideUpdate(normalized);
			}
			else
			{
				OnSlideEnd();
			}
		}
	}
	[BepInPlugin("SlidingCompany", "SlidingCompany", "1.0.0")]
	public class Plugin : BaseUnityPlugin
	{
		private void Awake()
		{
			((BaseUnityPlugin)this).Logger.LogInfo((object)"Plugin SlidingCompany is loaded!");
			Harmony.CreateAndPatchAll(typeof(Plugin), (string)null);
		}

		[HarmonyPatch(typeof(PlayerControllerB), "Start")]
		[HarmonyPostfix]
		private static void AttachPlayerSlideScript(PlayerControllerB __instance)
		{
			((Component)__instance.thisPlayerBody).gameObject.AddComponent<PlayerSlideController>().playerController = __instance;
		}

		[HarmonyPatch(typeof(PlayerControllerB), "Crouch_performed")]
		[HarmonyPrefix]
		private static bool AllowCrouchWhileJumping(PlayerControllerB __instance, CallbackContext context)
		{
			if (!((CallbackContext)(ref context)).performed)
			{
				return false;
			}
			if (__instance.quickMenuManager.isMenuOpen)
			{
				return false;
			}
			if ((!((NetworkBehaviour)__instance).IsOwner || !__instance.isPlayerControlled || (((NetworkBehaviour)__instance).IsServer && !__instance.isHostPlayerObject)) && !__instance.isTestingPlayer)
			{
				return false;
			}
			if (__instance.inSpecialInteractAnimation || __instance.isTypingChat)
			{
				return false;
			}
			__instance.Crouch(!__instance.isCrouching);
			__instance.playerBodyAnimator.SetBool("Jumping", false);
			if (__instance.isCrouching)
			{
				IngamePlayerSettings.Instance.playerInput.actions.FindAction("Sprint", false).Disable();
			}
			return false;
		}

		[HarmonyPatch(typeof(PlayerControllerB), "Jump_performed")]
		[HarmonyPrefix]
		private static bool AllowJumpWhileCrouching(PlayerControllerB __instance, CallbackContext context, ref bool ___isJumping, ref float ___playerSlidingTimer, ref Coroutine ___jumpCoroutine)
		{
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			if (__instance.quickMenuManager.isMenuOpen)
			{
				return false;
			}
			if ((!((NetworkBehaviour)__instance).IsOwner || !__instance.isPlayerControlled || (((NetworkBehaviour)__instance).IsServer && !__instance.isHostPlayerObject)) && !__instance.isTestingPlayer)
			{
				return false;
			}
			if (__instance.inSpecialInteractAnimation)
			{
				return false;
			}
			if (__instance.isTypingChat)
			{
				return false;
			}
			if (__instance.isMovementHindered > 0 && !__instance.isUnderwater)
			{
				return false;
			}
			if (__instance.isExhausted)
			{
				return false;
			}
			bool flag = Physics.Raycast(new Ray(((Component)__instance).transform.position, Vector3.down), 0.15f, StartOfRound.Instance.allPlayersCollideWithMask, (QueryTriggerInteraction)1);
			if ((__instance.thisController.isGrounded || (!___isJumping && flag)) && !___isJumping && (!__instance.isPlayerSliding || ___playerSlidingTimer > 2.5f))
			{
				___playerSlidingTimer = 0f;
				___isJumping = true;
				__instance.isCrouching = false;
				__instance.playerBodyAnimator.SetBool("Crouching", false);
				__instance.sprintMeter = Mathf.Clamp(__instance.sprintMeter - 0.08f, 0f, 1f);
				__instance.movementAudio.PlayOneShot(StartOfRound.Instance.playerJumpSFX);
				if (___jumpCoroutine != null)
				{
					((MonoBehaviour)__instance).StopCoroutine(___jumpCoroutine);
				}
				MethodInfo method = typeof(PlayerControllerB).GetMethod("PlayerJump", BindingFlags.Instance | BindingFlags.NonPublic);
				___jumpCoroutine = ((MonoBehaviour)__instance).StartCoroutine((IEnumerator)method.Invoke(__instance, new object[0]));
			}
			return false;
		}
	}
	public static class PluginInfo
	{
		public const string PLUGIN_GUID = "SlidingCompany";

		public const string PLUGIN_NAME = "SlidingCompany";

		public const string PLUGIN_VERSION = "1.0.0";
	}
}