using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using GameNetcodeStuff;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using OoLunar.LethalCompanyPatched.Patches;
using TMPro;
using Unity.Netcode;
using UnityEngine;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: IgnoresAccessChecksTo("Assembly-CSharp")]
[assembly: IgnoresAccessChecksTo("Unity.InputSystem")]
[assembly: IgnoresAccessChecksTo("Unity.Netcode.Runtime")]
[assembly: IgnoresAccessChecksTo("Unity.TextMeshPro")]
[assembly: IgnoresAccessChecksTo("UnityEngine.UI")]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("LethalCompanyPatched")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyDescription("A continuation of An0n_Patches.")]
[assembly: AssemblyFileVersion("1.2.1.0")]
[assembly: AssemblyInformationalVersion("1.2.1")]
[assembly: AssemblyProduct("LethalCompanyPatched")]
[assembly: AssemblyTitle("LethalCompanyPatched")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.2.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.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
internal sealed class NullableAttribute : Attribute
{
public readonly byte[] NullableFlags;
public NullableAttribute(byte P_0)
{
NullableFlags = new byte[1] { P_0 };
}
public NullableAttribute(byte[] P_0)
{
NullableFlags = P_0;
}
}
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
internal sealed class NullableContextAttribute : Attribute
{
public readonly byte Flag;
public NullableContextAttribute(byte P_0)
{
Flag = P_0;
}
}
[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 OoLunar.LethalCompanyPatched
{
[BepInPlugin("LethalCompanyPatched", "LethalCompanyPatched", "1.2.1")]
public sealed class LethalCompanyPatchedPlugin : BaseUnityPlugin
{
private readonly Harmony _harmony = new Harmony("LethalCompanyPatched");
internal static ManualLogSource StaticLogger;
internal static ConfigEntry<float> InstantSprint;
internal static ConfigEntry<float> Slipperiness;
internal static ConfigEntry<float> JumpDelay;
internal static ConfigEntry<bool> ShowHudPercentages;
internal static ConfigEntry<bool> CrouchHold;
private void Awake()
{
((BaseUnityPlugin)this).Logger.LogDebug((object)"LethalCompanyPatched started loading!");
StaticLogger = ((BaseUnityPlugin)this).Logger;
CrouchHold = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "crouchHold", true, "Enable/disable crouch hold. If disabled, crouch functions as a toggle with the additional behavior of going back into a crouch upon landing from a crouch jump.");
JumpDelay = ((BaseUnityPlugin)this).Config.Bind<float>("General", "jumpDelay", 0f, "Configure the time till jump, defaults to instant with 0.0. Vanilla is 0.15");
InstantSprint = ((BaseUnityPlugin)this).Config.Bind<float>("General", "instantSprint", 2.25f, "How fast to accelerate to sprint value of 2.25. 2.25 is the max, so it's instant acceleration. Vanilla is 1.0");
Slipperiness = ((BaseUnityPlugin)this).Config.Bind<float>("General", "slipperiness", 10f, "The amount of slipperiness when running and changing direction. 10-15f is a good value for little to no slippery feeling. Vanilla is 5.0");
ShowHudPercentages = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "showHealthStamina", true, "Show your health and sprint/stamina % on the HUD.");
Type[] types = typeof(LethalCompanyPatchedPlugin).Assembly.GetTypes();
foreach (Type type in types)
{
if (type.GetCustomAttribute<LethalPatchAttribute>() != null)
{
_harmony.PatchAll(type);
}
}
((BaseUnityPlugin)this).Logger.LogInfo((object)"LethalCompanyPatched finished loading!");
}
}
public static class MyPluginInfo
{
public const string PLUGIN_GUID = "LethalCompanyPatched";
public const string PLUGIN_NAME = "LethalCompanyPatched";
public const string PLUGIN_VERSION = "1.2.1";
}
}
namespace OoLunar.LethalCompanyPatched.Patches
{
[HarmonyPatch]
[LethalPatch]
internal class HUDManagerPatch : MonoBehaviour
{
private static bool _instantiating = true;
private static TextMeshProUGUI? _hudPercentagesText;
[HarmonyPostfix]
[HarmonyPatch(typeof(StartOfRound), "SceneManager_OnLoadComplete1")]
public static void CreateHudPercentages()
{
//IL_0053: Unknown result type (might be due to invalid IL or missing references)
//IL_0080: Unknown result type (might be due to invalid IL or missing references)
//IL_0085: Unknown result type (might be due to invalid IL or missing references)
//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
if (_instantiating)
{
GameObject obj = GameObject.Find("Systems/UI/Canvas/IngamePlayerHUD/TopLeftCorner/WeightUI");
GameObject val = GameObject.Find("Systems/UI/Canvas/IngamePlayerHUD/TopLeftCorner");
GameObject obj2 = Object.Instantiate<GameObject>(obj, val.transform);
((Object)obj2).name = "HPSP";
GameObject gameObject = ((Component)obj2.transform.GetChild(0)).gameObject;
gameObject.GetComponent<RectTransform>().anchoredPosition = new Vector2(-45f, 10f);
_hudPercentagesText = gameObject.GetComponent<TextMeshProUGUI>();
((TMP_Text)_hudPercentagesText).faceColor = Color32.op_Implicit(new Color(255f, 0f, 0f, 255f));
((TMP_Text)_hudPercentagesText).fontSize = 12f;
((TMP_Text)_hudPercentagesText).margin = new Vector4(0f, -36f, 100f, 0f);
((TMP_Text)_hudPercentagesText).alignment = (TextAlignmentOptions)260;
((TMP_Text)_hudPercentagesText).text = "";
_instantiating = false;
}
}
[HarmonyPrefix]
[HarmonyPatch(typeof(GameNetworkManager), "Disconnect")]
public static void UnInstantiate()
{
_instantiating = true;
}
[HarmonyPostfix]
[HarmonyPatch(typeof(HUDManager), "Update")]
public static void Update()
{
PlayerControllerB localPlayerController = GameNetworkManager.Instance.localPlayerController;
if (!((Object)(object)localPlayerController == (Object)null) && !_instantiating && !((Object)(object)_hudPercentagesText == (Object)null))
{
float num = Mathf.RoundToInt((float)localPlayerController.health);
int num2 = Math.Max(Mathf.RoundToInt((localPlayerController.sprintMeter * 100f - 10f) / 90f * 100f), 0);
((TMP_Text)_hudPercentagesText).text = (LethalCompanyPatchedPlugin.ShowHudPercentages.Value ? $"{num}\n\n\n\n{num2}%" : "");
}
}
}
[AttributeUsage(AttributeTargets.Class)]
public sealed class LethalPatchAttribute : Attribute
{
}
[HarmonyPatch(typeof(PlayerControllerB))]
[LethalPatch]
internal class PlayerControllerPatch
{
private static readonly FieldInfo? _playerCarryWeight = AccessTools.Field(typeof(PlayerControllerB), "carryWeight");
private static readonly FieldInfo? _slipperinessConfigField = AccessTools.Field(typeof(LethalCompanyPatchedPlugin), "Slipperiness");
private static readonly FieldInfo? _jumpDelayConfigField = AccessTools.Field(typeof(LethalCompanyPatchedPlugin), "JumpDelay");
private static readonly FieldInfo? _instantSprintConfigField = AccessTools.Field(typeof(LethalCompanyPatchedPlugin), "InstantSprint");
private static readonly MethodInfo? _configEntryFloatValueMethod = AccessTools.Method(typeof(ConfigEntry<float>), "get_Value", (Type[])null, (Type[])null);
private static bool _tempCrouch;
private static readonly int _crouchingId = Animator.StringToHash("crouching");
private static readonly int _startCrouchingId = Animator.StringToHash("startCrouching");
private static bool ReplaceInstruction(List<CodeInstruction> instructions, List<CodeInstruction> newInstructions, Predicate<int> whereClause, int lookAhead = 0, int lookBehind = 0)
{
int num = instructions.Count - lookAhead;
for (int i = lookBehind; i < num; i++)
{
if (whereClause(i))
{
instructions.RemoveAt(i);
instructions.InsertRange(i, newInstructions);
return true;
}
}
return false;
}
[HarmonyTranspiler]
[HarmonyPatch(/*Could not decode attribute arguments.*/)]
public static IEnumerable<CodeInstruction> RemoveJumpDelay(IEnumerable<CodeInstruction> instructions)
{
//IL_0050: Unknown result type (might be due to invalid IL or missing references)
//IL_005a: Expected O, but got Unknown
//IL_0065: Unknown result type (might be due to invalid IL or missing references)
//IL_006f: Expected O, but got Unknown
List<CodeInstruction> list = new List<CodeInstruction>();
foreach (CodeInstruction instruction in instructions)
{
list.Add(instruction);
}
List<CodeInstruction> currentInstructions = list;
List<CodeInstruction> newInstructions = new List<CodeInstruction>
{
new CodeInstruction(OpCodes.Ldsfld, (object)_jumpDelayConfigField),
new CodeInstruction(OpCodes.Callvirt, (object)_configEntryFloatValueMethod)
};
if (ReplaceInstruction(currentInstructions, newInstructions, (int instructionIndex) => currentInstructions[instructionIndex + 1].opcode == OpCodes.Newobj && ((ConstructorInfo)currentInstructions[instructionIndex + 1].operand).DeclaringType == typeof(WaitForSeconds), 1))
{
LethalCompanyPatchedPlugin.StaticLogger.LogDebug((object)"Patched Jump-Delay");
}
else
{
LethalCompanyPatchedPlugin.StaticLogger.LogError((object)"Failed to patch Jump-Delay, the player's jump will have it's default delay.");
}
return currentInstructions;
}
[HarmonyTranspiler]
[HarmonyPatch(typeof(PlayerControllerB), "Update")]
public static IEnumerable<CodeInstruction> FixSlipperiness(IEnumerable<CodeInstruction> instructions)
{
//IL_0050: Unknown result type (might be due to invalid IL or missing references)
//IL_005a: Expected O, but got Unknown
//IL_0065: Unknown result type (might be due to invalid IL or missing references)
//IL_006f: Expected O, but got Unknown
List<CodeInstruction> list = new List<CodeInstruction>();
foreach (CodeInstruction instruction in instructions)
{
list.Add(instruction);
}
List<CodeInstruction> currentInstructions = list;
List<CodeInstruction> newInstructions = new List<CodeInstruction>
{
new CodeInstruction(OpCodes.Ldsfld, (object)_slipperinessConfigField),
new CodeInstruction(OpCodes.Callvirt, (object)_configEntryFloatValueMethod)
};
if (ReplaceInstruction(currentInstructions, newInstructions, (int instructionIndex) => currentInstructions[instructionIndex].opcode == OpCodes.Ldc_R4 && Mathf.Approximately((float)currentInstructions[instructionIndex].operand, 5f) && CodeInstructionExtensions.LoadsField(currentInstructions[instructionIndex + 2], _playerCarryWeight, false) && currentInstructions[instructionIndex + 3].opcode == OpCodes.Ldc_R4 && Mathf.Approximately((float)currentInstructions[instructionIndex + 3].operand, 1.5f), 3))
{
LethalCompanyPatchedPlugin.StaticLogger.LogDebug((object)"Patched Slipperiness");
}
else
{
LethalCompanyPatchedPlugin.StaticLogger.LogError((object)"Failed to patch Slipperiness, the player will have the default slipperiness.");
}
return currentInstructions;
}
[HarmonyTranspiler]
[HarmonyPatch(typeof(PlayerControllerB), "Update")]
public static IEnumerable<CodeInstruction> InstantSprint(IEnumerable<CodeInstruction> instructions)
{
//IL_0050: Unknown result type (might be due to invalid IL or missing references)
//IL_005a: Expected O, but got Unknown
//IL_0065: Unknown result type (might be due to invalid IL or missing references)
//IL_006f: Expected O, but got Unknown
List<CodeInstruction> list = new List<CodeInstruction>();
foreach (CodeInstruction instruction in instructions)
{
list.Add(instruction);
}
List<CodeInstruction> currentInstructions = list;
List<CodeInstruction> newInstructions = new List<CodeInstruction>
{
new CodeInstruction(OpCodes.Ldsfld, (object)_instantSprintConfigField),
new CodeInstruction(OpCodes.Callvirt, (object)_configEntryFloatValueMethod)
};
if (ReplaceInstruction(currentInstructions, newInstructions, (int instructionIndex) => currentInstructions[instructionIndex - 3].opcode == OpCodes.Ldfld && ((object)currentInstructions[instructionIndex - 3]).ToString() == "ldfld float GameNetcodeStuff.PlayerControllerB::sprintMultiplier" && currentInstructions[instructionIndex - 2].opcode == OpCodes.Ldc_R4 && Mathf.Approximately((float)currentInstructions[instructionIndex - 2].operand, 2.25f) && currentInstructions[instructionIndex].opcode == OpCodes.Ldc_R4 && Mathf.Approximately((float)currentInstructions[instructionIndex].operand, 1f), 0, 3))
{
LethalCompanyPatchedPlugin.StaticLogger.LogDebug((object)"Patched Instant-Sprint");
}
else
{
LethalCompanyPatchedPlugin.StaticLogger.LogError((object)"Failed to patch Instant-Sprint, the player will have the default sprint speed.");
}
return currentInstructions;
}
[HarmonyPostfix]
[HarmonyPatch(typeof(PlayerControllerB), "Update")]
public static void HoldCrouch(PlayerControllerB __instance)
{
PlayerControllerB localPlayerController = GameNetworkManager.Instance.localPlayerController;
if (LethalCompanyPatchedPlugin.CrouchHold.Value && !((Object)(object)localPlayerController == (Object)null) && (!((NetworkBehaviour)__instance).IsOwner || !__instance.isPlayerControlled || (((NetworkBehaviour)__instance).IsServer && !__instance.isHostPlayerObject)) && !__instance.isTestingPlayer && !__instance.inTerminalMenu && !__instance.isTypingChat && !__instance.isPlayerDead && !__instance.quickMenuManager.isMenuOpen && !IngamePlayerSettings.Instance.playerInput.actions.FindAction("Crouch", true).IsPressed() && localPlayerController.playerBodyAnimator.GetBool(_crouchingId) && CanJump(__instance))
{
localPlayerController.isCrouching = false;
localPlayerController.playerBodyAnimator.SetBool(_crouchingId, false);
}
}
[HarmonyPrefix]
[HarmonyPatch(typeof(PlayerControllerB), "Jump_performed")]
public static void PreJump(PlayerControllerB __instance)
{
if (__instance.isCrouching && CanJump(__instance))
{
__instance.isCrouching = false;
_tempCrouch = true;
}
}
[HarmonyPostfix]
[HarmonyPatch(typeof(PlayerControllerB), "Jump_performed")]
public static void PostJump(PlayerControllerB __instance)
{
if (_tempCrouch)
{
__instance.isCrouching = true;
_tempCrouch = false;
}
}
[HarmonyPostfix]
[HarmonyPatch(typeof(PlayerControllerB), "PlayerHitGroundEffects")]
public static void PostPlayerHitGroundEffects(PlayerControllerB __instance)
{
if (__instance.isCrouching)
{
__instance.playerBodyAnimator.SetTrigger(_startCrouchingId);
__instance.playerBodyAnimator.SetBool(_crouchingId, true);
}
}
private static bool CanJump(PlayerControllerB __instance)
{
//IL_000b: Unknown result type (might be due to invalid IL or missing references)
//IL_0010: Unknown result type (might be due to invalid IL or missing references)
return !Physics.Raycast(((Component)__instance.gameplayCamera).transform.position, Vector3.up, ref __instance.hit, 0.72f, __instance.playersManager.collidersAndRoomMask, (QueryTriggerInteraction)1);
}
}
}
namespace System.Runtime.CompilerServices
{
[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
internal sealed class IgnoresAccessChecksToAttribute : Attribute
{
public IgnoresAccessChecksToAttribute(string assemblyName)
{
}
}
}
