Decompiled source of UltraStrafe v1.1.1

UltraStrafe.dll

Decompiled 2 months ago
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using HarmonyLib.Tools;
using Microsoft.CodeAnalysis;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.0", FrameworkDisplayName = ".NET Standard 2.0")]
[assembly: AssemblyCompany("UltraStrafe")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.1.1.0")]
[assembly: AssemblyInformationalVersion("1.1.1+1dceb115566da61a89a3dd11afccfb9577c6eab6")]
[assembly: AssemblyProduct("UltraStrafe")]
[assembly: AssemblyTitle("UltraStrafe")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.1.1.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 UltraStrafe
{
	internal class ConfigManager
	{
		internal ConfigFile Config;

		public Dictionary<string, object> Cvars;

		internal static ConfigEntry<float> sv_accelerate;

		internal static ConfigEntry<float> sv_maxspeed;

		internal static ConfigEntry<byte> sv_maxfrictionlessframes;

		internal static ConfigEntry<bool> sv_acceltweak;

		internal static ConfigEntry<float> sv_switchspeed;

		internal static ConfigEntry<bool> sv_autobhop;

		internal static ConfigEntry<float> sv_jumppower;

		public ConfigManager(ConfigFile config)
		{
			Config = config;
			Cvars = new Dictionary<string, object>
			{
				{ "sv_accelerate", sv_accelerate },
				{ "sv_maxspeed", sv_maxspeed },
				{ "sv_maxfrictionlessframes", sv_maxfrictionlessframes },
				{ "sv_acceltweak", sv_acceltweak },
				{ "sv_switchspeed", sv_switchspeed },
				{ "sv_autobhop", sv_autobhop },
				{ "sv_jumppower", sv_jumppower }
			};
			base..ctor();
		}

		public void Reload()
		{
			sv_accelerate = Config.Bind<float>("Cvars", "sv_accelerate", 70f, "The (base) acceleration value for the strafe movement, affecting the turn radius.");
			sv_maxspeed = Config.Bind<float>("Cvars", "sv_maxspeed", 0f, "The maximum speed value for the strafe movement. Set to 0 for no maximum");
			sv_jumppower = Config.Bind<float>("Cvars", "sv_jumppower", 90f, "The jump power for jumping (note that this affects all jumps, not just bhops.");
			sv_maxfrictionlessframes = Config.Bind<byte>("Cvars", "sv_maxfrictionlessframes", (byte)2, "The maximum number of frames that friction is disabled for when landing. A value from 2-4 is recommended depending on your specs with lower framerates having a higher value.");
			sv_acceltweak = Config.Bind<bool>("Cvars", "sv_acceltweak", true, "Enable this to make sv_accelerate increase based on your speed");
			sv_switchspeed = Config.Bind<float>("Cvars", "sv_switchspeed", 16.5f, "The speed at which it switches from ultrakill physics (low speeds) to quake (high speeds). I don't recommend changing unless you know what you're doing.");
			sv_autobhop = Config.Bind<bool>("Cvars", "sv_autobhop", false, "Enable this to make the game automatically jump while holding jump, without any need to release the jump key");
		}
	}
	internal static class JumpBuffer
	{
		private static bool jumpBuffer = false;

		private static readonly FieldRef<NewMovement, WallCheck> wcRef = AccessTools.FieldRefAccess<NewMovement, WallCheck>("wc");

		private static readonly FieldRef<NewMovement, float> clingFadeRef = AccessTools.FieldRefAccess<NewMovement, float>("clingFade");

		private static readonly FieldRef<NewMovement, bool> jumpCooldownRef = AccessTools.FieldRefAccess<NewMovement, bool>("jumpCooldown");

		private static readonly FieldRef<NewMovement, bool> fallingRef = AccessTools.FieldRefAccess<NewMovement, bool>("falling");

		public static void JumpBufferCheck(NewMovement __instance)
		{
			if (MonoSingleton<InputManager>.Instance.InputSource.Jump.WasPerformedThisFrame)
			{
				jumpBuffer = true;
			}
			if (!GameStateManager.Instance.PlayerInputLocked && jumpBuffer && MonoSingleton<InputManager>.Instance.InputSource.Jump.IsPressed && !jumpCooldownRef.Invoke(__instance) && (!fallingRef.Invoke(__instance) || __instance.gc.canJump || wcRef.Invoke(__instance).CheckForEnemyCols()))
			{
				if (__instance.gc.canJump || wcRef.Invoke(__instance).CheckForEnemyCols())
				{
					__instance.currentWallJumps = 0;
					__instance.rocketJumps = 0;
					__instance.hammerJumps = 0;
					clingFadeRef.Invoke(__instance) = 0f;
					__instance.rocketRides = 0;
				}
				jumpBuffer = ConfigManager.sv_autobhop.Value;
				__instance.Jump();
			}
		}
	}
	[HarmonyPatch(typeof(NewMovement))]
	public class MovementPatcher
	{
		[HarmonyPatch(typeof(NewMovement), "Move")]
		[HarmonyPrefix]
		private static bool MovePrefix(NewMovement __instance)
		{
			new QuakeMovement(__instance).NewMove();
			return false;
		}

		[HarmonyPatch(typeof(NewMovement), "Update")]
		[HarmonyPrefix]
		private static bool UpdatePrefix(NewMovement __instance)
		{
			JumpBuffer.JumpBufferCheck(__instance);
			return true;
		}

		[HarmonyPatch(typeof(NewMovement), "Jump")]
		[HarmonyPrefix]
		private static bool JumpPrefix(NewMovement __instance)
		{
			__instance.jumpPower = ConfigManager.sv_jumppower.Value;
			return true;
		}
	}
	[BepInPlugin("com.10-days-till-xmas.ultrastrafe", "UltraStrafe", "1.1.1")]
	public class Plugin : BaseUnityPlugin
	{
		internal static ManualLogSource Logger;

		internal static ConfigManager ConfigManager;

		internal void Awake()
		{
			Logger = ((BaseUnityPlugin)this).Logger;
			Logger.LogInfo((object)"Plugin UltraStrafe is loaded! :3");
			ConfigManager = new ConfigManager(((BaseUnityPlugin)this).Config);
			ConfigManager.Reload();
			DoPatching();
		}

		private void DoPatching()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			Harmony val = new Harmony("com.10-days-till-xmas.ultrastrafe");
			HarmonyFileLog.Enabled = true;
			val.PatchAll();
			Logger.LogInfo((object)"Patches applied!");
		}

		[HarmonyPostfix]
		[HarmonyPatch(/*Could not decode attribute arguments.*/)]
		private static void ScoresSubmission(ref bool __result)
		{
			__result = false;
		}
	}
	internal class QuakeMovement
	{
		private readonly NewMovement __instance;

		private float wishspeed;

		private static int frictionlessFrames = 0;

		private static readonly FieldRef<NewMovement, bool> slideEndingRef = AccessTools.FieldRefAccess<NewMovement, bool>("slideEnding");

		private static readonly FieldRef<NewMovement, bool> hurtingRef = AccessTools.FieldRefAccess<NewMovement, bool>("hurting");

		private static readonly FieldRef<NewMovement, Vector3> movementDirectionRef = AccessTools.FieldRefAccess<NewMovement, Vector3>("movementDirection");

		private static readonly FieldRef<NewMovement, Vector3> movementDirection2Ref = AccessTools.FieldRefAccess<NewMovement, Vector3>("movementDirection2");

		private static readonly FieldRef<NewMovement, Vector3> airDirectionRef = AccessTools.FieldRefAccess<NewMovement, Vector3>("airDirection");

		private static readonly FieldRef<NewMovement, float> frictionRef = AccessTools.FieldRefAccess<NewMovement, float>("friction");

		public static float sv_accelerate = ConfigManager.sv_accelerate.Value;

		public static float sv_maxspeed = ConfigManager.sv_maxspeed.Value;

		public static int sv_maxfrictionlessframes = ConfigManager.sv_maxfrictionlessframes.Value;

		public static float sv_switchspeed = ConfigManager.sv_switchspeed.Value;

		public static bool sv_acceltweak = ConfigManager.sv_acceltweak.Value;

		public QuakeMovement(NewMovement __instance)
		{
			this.__instance = __instance;
			base..ctor();
		}

		private void NewGroundMove()
		{
			//IL_000b: 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_0121: 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_0131: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ee: 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_0166: Unknown result type (might be due to invalid IL or missing references)
			//IL_0198: Unknown result type (might be due to invalid IL or missing references)
			//IL_0199: Unknown result type (might be due to invalid IL or missing references)
			//IL_019b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a0: 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)
			//IL_018f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0191: Unknown result type (might be due to invalid IL or missing references)
			//IL_0196: Unknown result type (might be due to invalid IL or missing references)
			float num = __instance.rb.velocity.y;
			if (__instance.slopeCheck.onGround && movementDirectionRef.Invoke(__instance).x == 0f && movementDirectionRef.Invoke(__instance).z == 0f)
			{
				num = 0f;
				__instance.rb.useGravity = false;
			}
			else
			{
				__instance.rb.useGravity = true;
			}
			float num2 = (__instance.slowMode ? 1.25f : 2.75f);
			if (Object.op_Implicit((Object)(object)__instance.groundProperties))
			{
				num2 *= __instance.groundProperties.speedMultiplier;
			}
			float num3 = __instance.walkSpeed * Time.deltaTime * num2;
			movementDirection2Ref.Invoke(__instance) = new Vector3(movementDirectionRef.Invoke(__instance).x * num3, num, movementDirectionRef.Invoke(__instance).z * num3);
			Vector3 val = __instance.pushForce;
			if (Object.op_Implicit((Object)(object)__instance.groundProperties) && __instance.groundProperties.push)
			{
				Vector3 val2 = __instance.groundProperties.pushForce;
				if (__instance.groundProperties.pushDirectionRelative)
				{
					val2 = ((Component)__instance.groundProperties).transform.rotation * val2;
				}
				val += val2;
			}
			__instance.rb.velocity = Vector3.Lerp(__instance.rb.velocity, movementDirection2Ref.Invoke(__instance) + val, 0.25f * frictionRef.Invoke(__instance));
			__instance.anim.SetBool("Run", false);
		}

		private float NewAcceleration(float speed)
		{
			float num = Mathf.Clamp(Mathf.Log(speed - 8.5f, 2f) - 2f, 1f, 10f);
			return sv_accelerate * num;
		}

		private void NewAirMove()
		{
			//IL_001c: 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_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_020c: 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_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_029e: 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_0138: Unknown result type (might be due to invalid IL or missing references)
			//IL_0139: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0340: Unknown result type (might be due to invalid IL or missing references)
			//IL_0350: Unknown result type (might be due to invalid IL or missing references)
			__instance.rb.useGravity = true;
			Vector2 val = new Vector2(__instance.rb.velocity.x, __instance.rb.velocity.z);
			float magnitude = ((Vector2)(ref val)).magnitude;
			if (magnitude > sv_switchspeed)
			{
				Vector3 val2 = default(Vector3);
				((Vector3)(ref val2))..ctor(movementDirectionRef.Invoke(__instance).x, 0f, movementDirectionRef.Invoke(__instance).z);
				wishspeed = ((Vector3)(ref val2)).magnitude;
				if (wishspeed > sv_maxspeed && sv_maxspeed != 0f)
				{
					val2 *= sv_maxspeed / wishspeed;
					wishspeed = sv_maxspeed;
				}
				float num = Vector3.Dot(__instance.rb.velocity, val2);
				float num2 = wishspeed - num;
				if (!(num2 <= 0f))
				{
					float num3 = Time.deltaTime * wishspeed * (sv_acceltweak ? NewAcceleration(magnitude) : sv_accelerate);
					if (num3 > num2)
					{
						num3 = num2;
					}
					Rigidbody rb = __instance.rb;
					rb.velocity += num3 * val2;
				}
			}
			else
			{
				float num4 = (__instance.slowMode ? 1.25f : 2.75f);
				movementDirection2Ref.Invoke(__instance) = new Vector3(movementDirectionRef.Invoke(__instance).x * __instance.walkSpeed * Time.deltaTime * num4, __instance.rb.velocity.y, movementDirectionRef.Invoke(__instance).z * __instance.walkSpeed * Time.deltaTime * num4);
				airDirectionRef.Invoke(__instance).y = 0f;
				if (__instance.rb.velocity.x * movementDirection2Ref.Invoke(__instance).x < Mathf.Pow(movementDirection2Ref.Invoke(__instance).x, 2f))
				{
					airDirectionRef.Invoke(__instance).x = movementDirection2Ref.Invoke(__instance).x;
				}
				else
				{
					airDirectionRef.Invoke(__instance).x = 0f;
				}
				if (__instance.rb.velocity.z * movementDirection2Ref.Invoke(__instance).z < Mathf.Pow(movementDirection2Ref.Invoke(__instance).z, 2f))
				{
					airDirectionRef.Invoke(__instance).z = movementDirection2Ref.Invoke(__instance).z;
				}
				else
				{
					airDirectionRef.Invoke(__instance).z = 0f;
				}
				__instance.rb.AddForce(((Vector3)(ref airDirectionRef.Invoke(__instance))).normalized * __instance.airAcceleration);
			}
		}

		public void NewMove()
		{
			slideEndingRef.Invoke(__instance) = false;
			if (!hurtingRef.Invoke(__instance) && !__instance.levelOver)
			{
				((Component)__instance).gameObject.layer = 2;
				__instance.exploded = false;
			}
			if (__instance.gc.onGround && !__instance.jumping)
			{
				__instance.currentWallJumps = 0;
				__instance.rocketJumps = 0;
				__instance.hammerJumps = 0;
				__instance.rocketRides = 0;
			}
			if (__instance.gc.onGround && frictionRef.Invoke(__instance) > 0f && !__instance.jumping)
			{
				if (frictionlessFrames == 0)
				{
					NewGroundMove();
				}
				else
				{
					frictionlessFrames--;
				}
			}
			else
			{
				NewAirMove();
				frictionlessFrames = sv_maxfrictionlessframes;
			}
		}
	}
	public static class UltraStrafePluginInfo
	{
		public const string PLUGIN_GUID = "com.10-days-till-xmas.ultrastrafe";

		public const string PLUGIN_NAME = "UltraStrafe";

		public const string PLUGIN_VERSION = "1.1.1";
	}
}