using System;
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 BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using UnityEngine;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: AssemblyTitle("UnlimitedPhysicalStrength")]
[assembly: AssemblyDescription("无限体力模组 for REPO")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("hyy")]
[assembly: AssemblyProduct("UnlimitedPhysicalStrength")]
[assembly: AssemblyCopyright("Copyright © hyy 2025")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("45e9cac9-6b1f-46f0-b1f3-f37575e133fd")]
[assembly: AssemblyFileVersion("0.1.1.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: AssemblyVersion("0.1.1.0")]
namespace UnlimitedPhysicalStrength
{
[BepInPlugin("hyy.REPO.UnlimitedPhysicalStrength", "Unlimited Physical Strength", "0.1.1")]
[BepInProcess("REPO.exe")]
[BepInDependency("nickklmao.menulib", "2.5.0")]
public class UnlimitedPhysicalStrength : BaseUnityPlugin
{
private ConfigEntry<bool> configEnableMod;
private ConfigEntry<bool> configInfiniteStamina;
private ConfigEntry<bool> configBlockOtherMods;
private ConfigEntry<bool> configEnableAutoRegen;
private ConfigEntry<bool> configNoStaminaDrain;
private ConfigEntry<bool> configInstantStaminaRecovery;
private ConfigEntry<float> configStaminaMultiplier;
private ConfigEntry<float> configCustomMaxStamina;
private ConfigEntry<bool> configModifyMaxStamina;
private ConfigEntry<KeyboardShortcut> configToggleHotkey;
private ConfigEntry<bool> configDebugMode;
private bool isModEnabled = true;
private bool lastModState = true;
private float lastStaminaValue = 0f;
private float checkInterval = 0.5f;
private float checkTimer = 0f;
private Harmony harmony;
private static object currentPlayerController;
private static float originalMaxStamina = 100f;
private static bool isOriginalMaxStaminaSaved = false;
internal static ManualLogSource Logger { get; private set; }
public static UnlimitedPhysicalStrength Instance { get; private set; }
public static bool IsModEnabled => Instance?.isModEnabled ?? false;
public static bool InfiniteStaminaEnabled => Instance?.configInfiniteStamina.Value ?? true;
public static bool BlockOtherModsEnabled => Instance?.configBlockOtherMods.Value ?? true;
public static bool AutoRegenEnabled => Instance?.configEnableAutoRegen.Value ?? true;
public static bool NoStaminaDrainEnabled => Instance?.configNoStaminaDrain.Value ?? true;
public static bool InstantStaminaRecoveryEnabled => Instance?.configInstantStaminaRecovery.Value ?? true;
public static float StaminaMultiplier => Instance?.configStaminaMultiplier.Value ?? 1f;
public static float CustomMaxStamina => Instance?.configCustomMaxStamina.Value ?? 100f;
public static bool ModifyMaxStamina => Instance?.configModifyMaxStamina.Value ?? false;
public static bool DebugMode => Instance?.configDebugMode.Value ?? false;
private void Awake()
{
//IL_002b: Unknown result type (might be due to invalid IL or missing references)
//IL_0035: Expected O, but got Unknown
//IL_013b: Unknown result type (might be due to invalid IL or missing references)
if ((Object)(object)Instance == (Object)null)
{
Instance = this;
}
Logger = ((BaseUnityPlugin)this).Logger;
harmony = new Harmony("hyy.REPO.UnlimitedPhysicalStrength");
LoadConfig();
ApplyPatches();
Logger.LogInfo((object)"==========================================================================");
Logger.LogInfo((object)"Unlimited Physical Strength v0.1.1 by hyy");
Logger.LogInfo((object)"GUID: hyy.REPO.UnlimitedPhysicalStrength");
Logger.LogInfo((object)"==========================================================================");
Logger.LogInfo((object)("Mod Status: " + (isModEnabled ? "ENABLED" : "DISABLED")));
Logger.LogInfo((object)$"Infinite Stamina: {configInfiniteStamina.Value}");
Logger.LogInfo((object)$"Custom Max Stamina: {configCustomMaxStamina.Value} (Enabled: {configModifyMaxStamina.Value})");
Logger.LogInfo((object)$"Block Other Mods: {configBlockOtherMods.Value}");
Logger.LogInfo((object)$"Toggle Hotkey: {configToggleHotkey.Value}");
Logger.LogInfo((object)"==========================================================================");
}
private void Update()
{
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
//IL_000c: Unknown result type (might be due to invalid IL or missing references)
KeyboardShortcut value = configToggleHotkey.Value;
if (((KeyboardShortcut)(ref value)).IsDown())
{
ToggleModEnabled();
}
checkTimer += Time.deltaTime;
if (checkTimer >= checkInterval && DebugMode)
{
checkTimer = 0f;
CheckStaminaStatus();
}
}
private void OnDestroy()
{
if (harmony != null)
{
harmony.UnpatchSelf();
Logger.LogInfo((object)"Harmony patches unloaded");
}
}
private void LoadConfig()
{
//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
//IL_0100: Expected O, but got Unknown
//IL_0134: Unknown result type (might be due to invalid IL or missing references)
//IL_013e: Expected O, but got Unknown
//IL_017f: Unknown result type (might be due to invalid IL or missing references)
configEnableMod = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "EnableMod", true, "启用/禁用整个模组");
configInfiniteStamina = ((BaseUnityPlugin)this).Config.Bind<bool>("Stamina", "InfiniteStamina", true, "启用无限体力");
configBlockOtherMods = ((BaseUnityPlugin)this).Config.Bind<bool>("Stamina", "BlockOtherMods", true, "阻止其他模组修改体力");
configEnableAutoRegen = ((BaseUnityPlugin)this).Config.Bind<bool>("Stamina", "EnableAutoRegen", true, "启用自动体力回复");
configNoStaminaDrain = ((BaseUnityPlugin)this).Config.Bind<bool>("Stamina", "NoStaminaDrain", true, "完全阻止体力消耗");
configInstantStaminaRecovery = ((BaseUnityPlugin)this).Config.Bind<bool>("Stamina", "InstantStaminaRecovery", true, "即时体力恢复");
configStaminaMultiplier = ((BaseUnityPlugin)this).Config.Bind<float>("Stamina", "StaminaMultiplier", 1f, new ConfigDescription("体力倍率（仅在无限体力关闭时生效）", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.1f, 10f), Array.Empty<object>()));
configCustomMaxStamina = ((BaseUnityPlugin)this).Config.Bind<float>("Stamina", "CustomMaxStamina", 100f, new ConfigDescription("自定义最大体力值 (1-1000)", (AcceptableValueBase)(object)new AcceptableValueRange<float>(1f, 1000f), Array.Empty<object>()));
configModifyMaxStamina = ((BaseUnityPlugin)this).Config.Bind<bool>("Stamina", "ModifyMaxStamina", false, "启用自定义最大体力（修改后需要重启游戏或重新加载场景）");
configToggleHotkey = ((BaseUnityPlugin)this).Config.Bind<KeyboardShortcut>("Hotkeys", "ToggleMod", new KeyboardShortcut((KeyCode)289, Array.Empty<KeyCode>()), "切换模组启用/禁用的热键");
configDebugMode = ((BaseUnityPlugin)this).Config.Bind<bool>("Debug", "DebugMode", false, "启用调试模式（会在日志中显示更多信息）");
isModEnabled = configEnableMod.Value;
lastModState = isModEnabled;
}
private void ApplyPatches()
{
try
{
List<Type> list = new List<Type>();
Assembly executingAssembly = Assembly.GetExecutingAssembly();
Type[] types = executingAssembly.GetTypes();
foreach (Type type in types)
{
if (type.Namespace == "UnlimitedPhysicalStrength.Patches" && type.GetCustomAttributes(typeof(HarmonyPatch), inherit: false).Length != 0)
{
list.Add(type);
}
}
foreach (Type item in list)
{
harmony.PatchAll(item);
Logger.LogDebug((object)("Applied patch: " + item.Name));
}
Logger.LogInfo((object)$"成功应用 {list.Count} 个Harmony补丁");
if (BlockOtherModsEnabled)
{
ApplyUniversalProtection();
}
}
catch (Exception ex)
{
Logger.LogError((object)("应用补丁时出错: " + ex.Message));
Logger.LogError((object)ex.StackTrace);
}
}
private void ApplyUniversalProtection()
{
try
{
Logger.LogInfo((object)"全局体力保护已启用");
}
catch (Exception ex)
{
Logger.LogError((object)("应用全局保护时出错: " + ex.Message));
}
}
private void ToggleModEnabled()
{
isModEnabled = !isModEnabled;
configEnableMod.Value = isModEnabled;
if (isModEnabled)
{
Logger.LogInfo((object)"模组已启用");
if (!lastModState)
{
ApplyPatches();
}
}
else
{
Logger.LogInfo((object)"模组已禁用");
}
lastModState = isModEnabled;
ShowNotification("无限体力: " + (isModEnabled ? "启用" : "禁用"));
}
private void CheckStaminaStatus()
{
try
{
if (currentPlayerController == null)
{
return;
}
FieldInfo field = currentPlayerController.GetType().GetField("EnergyCurrent");
if (field != null)
{
float num = (float)field.GetValue(currentPlayerController);
if (Mathf.Abs(num - lastStaminaValue) > 0.01f)
{
Logger.LogDebug((object)$"体力变化: {lastStaminaValue} -> {num}");
lastStaminaValue = num;
}
}
}
catch
{
}
}
private void ShowNotification(string message)
{
try
{
Logger.LogInfo((object)("通知: " + message));
}
catch
{
Logger.LogInfo((object)message);
}
}
public static void SetPlayerController(object playerController)
{
currentPlayerController = playerController;
}
public static object GetPlayerController()
{
return currentPlayerController;
}
public static void SaveOriginalMaxStamina(float value)
{
if (!isOriginalMaxStaminaSaved)
{
originalMaxStamina = value;
isOriginalMaxStaminaSaved = true;
Logger.LogInfo((object)$"原始最大体力已保存: {originalMaxStamina}");
}
}
public static float GetOriginalMaxStamina()
{
return originalMaxStamina;
}
public static bool IsOriginalMaxStaminaSaved()
{
return isOriginalMaxStaminaSaved;
}
public static void ForceSetStamina(float value)
{
try
{
if (currentPlayerController != null)
{
FieldInfo field = currentPlayerController.GetType().GetField("EnergyCurrent");
if (field != null)
{
field.SetValue(currentPlayerController, value);
Logger.LogDebug((object)$"强制设置体力: {value}");
}
}
}
catch (Exception ex)
{
Logger.LogError((object)("强制设置体力时出错: " + ex.Message));
}
}
public static float GetEffectiveMaxStamina()
{
if (ModifyMaxStamina)
{
return CustomMaxStamina;
}
return GetOriginalMaxStamina();
}
}
}
namespace UnlimitedPhysicalStrength.Config
{
public static class ModConfig
{
public static ConfigEntry<bool> EnableMod { get; private set; }
public static ConfigEntry<bool> InfiniteStamina { get; private set; }
public static ConfigEntry<bool> BlockOtherMods { get; private set; }
public static ConfigEntry<bool> EnableAutoRegen { get; private set; }
public static ConfigEntry<bool> NoStaminaDrain { get; private set; }
public static ConfigEntry<bool> InstantStaminaRecovery { get; private set; }
public static ConfigEntry<float> StaminaMultiplier { get; private set; }
public static ConfigEntry<float> CustomMaxStamina { get; private set; }
public static ConfigEntry<bool> ModifyMaxStamina { get; private set; }
public static ConfigEntry<KeyboardShortcut> ToggleHotkey { get; private set; }
public static ConfigEntry<bool> DebugMode { get; private set; }
public static void Initialize(ConfigFile config)
{
//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
//IL_00fc: Expected O, but got Unknown
//IL_0133: Unknown result type (might be due to invalid IL or missing references)
EnableMod = config.Bind<bool>("General", "EnableMod", true, "启用/禁用整个模组");
InfiniteStamina = config.Bind<bool>("Stamina", "InfiniteStamina", true, "启用无限体力");
BlockOtherMods = config.Bind<bool>("Stamina", "BlockOtherMods", true, "阻止其他模组修改体力");
EnableAutoRegen = config.Bind<bool>("Stamina", "EnableAutoRegen", true, "启用自动体力回复");
NoStaminaDrain = config.Bind<bool>("Stamina", "NoStaminaDrain", true, "完全阻止体力消耗");
InstantStaminaRecovery = config.Bind<bool>("Stamina", "InstantStaminaRecovery", true, "即时体力恢复");
StaminaMultiplier = config.Bind<float>("Stamina", "StaminaMultiplier", 1f, "体力倍率（仅在无限体力关闭时生效）");
CustomMaxStamina = config.Bind<float>("Stamina", "CustomMaxStamina", 100f, new ConfigDescription("自定义最大体力值 (1-1000)", (AcceptableValueBase)(object)new AcceptableValueRange<float>(1f, 1000f), Array.Empty<object>()));
ModifyMaxStamina = config.Bind<bool>("Stamina", "ModifyMaxStamina", false, "启用自定义最大体力（修改后需要重启游戏或重新加载场景）");
ToggleHotkey = config.Bind<KeyboardShortcut>("Hotkeys", "ToggleMod", new KeyboardShortcut((KeyCode)289, Array.Empty<KeyCode>()), "切换模组启用/禁用的热键");
DebugMode = config.Bind<bool>("Debug", "DebugMode", false, "启用调试模式");
}
}
}
namespace UnlimitedPhysicalStrength.Patches
{
[HarmonyPatch]
public static class PlayerStaminaController
{
private static float lastDetectedStamina;
private static float lastMaxStamina;
internal static Type playerControllerType;
private static bool customMaxStaminaApplied;
static PlayerStaminaController()
{
lastDetectedStamina = 0f;
lastMaxStamina = 0f;
playerControllerType = null;
customMaxStaminaApplied = false;
try
{
Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
foreach (Assembly assembly in assemblies)
{
try
{
playerControllerType = assembly.GetType("PlayerController");
if (playerControllerType != null)
{
UnlimitedPhysicalStrength.Logger.LogInfo((object)("Found PlayerController type: " + playerControllerType.FullName));
break;
}
}
catch
{
}
}
if (playerControllerType == null)
{
UnlimitedPhysicalStrength.Logger.LogWarning((object)"PlayerController type not found, using dynamic lookup");
}
}
catch (Exception ex)
{
UnlimitedPhysicalStrength.Logger.LogError((object)("Error finding PlayerController type: " + ex.Message));
}
}
[HarmonyTargetMethods]
private static IEnumerable<MethodBase> TargetMethods()
{
List<MethodBase> list = new List<MethodBase>();
if (playerControllerType != null)
{
MethodInfo[] methods = playerControllerType.GetMethods(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
MethodInfo method = playerControllerType.GetMethod("Update", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
if (method != null)
{
list.Add(method);
}
MethodInfo method2 = playerControllerType.GetMethod("FixedUpdate", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
if (method2 != null)
{
list.Add(method2);
}
MethodInfo method3 = playerControllerType.GetMethod("LateUpdate", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
if (method3 != null)
{
list.Add(method3);
}
MethodInfo[] array = methods;
foreach (MethodInfo methodInfo in array)
{
string text = methodInfo.Name.ToLower();
if ((text.Contains("stamina") || text.Contains("energy") || text.Contains("update") || text.Contains("regenerate") || text.Contains("start") || text.Contains("awake")) && !list.Contains(methodInfo))
{
list.Add(methodInfo);
}
}
}
UnlimitedPhysicalStrength.Logger.LogInfo((object)$"Found {list.Count} methods to patch");
return list;
}
[HarmonyPostfix]
private static void Postfix(ref object __instance)
{
if (!UnlimitedPhysicalStrength.IsModEnabled)
{
return;
}
try
{
SaveOriginalMaxStamina(__instance);
ApplyCustomMaxStamina(__instance);
if (UnlimitedPhysicalStrength.InfiniteStaminaEnabled)
{
ApplyInfiniteStamina(__instance);
}
}
catch (Exception ex)
{
if (UnlimitedPhysicalStrength.DebugMode)
{
UnlimitedPhysicalStrength.Logger.LogError((object)("Error in stamina patch: " + ex.Message));
}
}
}
private static void SaveOriginalMaxStamina(object playerInstance)
{
if (playerInstance == null || UnlimitedPhysicalStrength.IsOriginalMaxStaminaSaved())
{
return;
}
Type type = playerInstance.GetType();
string[] array = new string[6] { "EnergyStart", "energyStart", "maxStamina", "MaxStamina", "maxEnergy", "MaxEnergy" };
string[] array2 = array;
foreach (string name in array2)
{
FieldInfo field = type.GetField(name, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
if (field != null)
{
try
{
float value = (float)field.GetValue(playerInstance);
UnlimitedPhysicalStrength.SaveOriginalMaxStamina(value);
break;
}
catch
{
}
}
}
}
private static void ApplyCustomMaxStamina(object playerInstance)
{
if (playerInstance == null || !UnlimitedPhysicalStrength.ModifyMaxStamina || customMaxStaminaApplied)
{
return;
}
Type type = playerInstance.GetType();
string[] array = new string[6] { "EnergyStart", "energyStart", "maxStamina", "MaxStamina", "maxEnergy", "MaxEnergy" };
string[] array2 = array;
foreach (string name in array2)
{
FieldInfo field = type.GetField(name, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
if (!(field != null))
{
continue;
}
try
{
float customMaxStamina = UnlimitedPhysicalStrength.CustomMaxStamina;
field.SetValue(playerInstance, customMaxStamina);
if (!customMaxStaminaApplied)
{
UnlimitedPhysicalStrength.Logger.LogInfo((object)$"应用自定义最大体力: {customMaxStamina}");
customMaxStaminaApplied = true;
}
break;
}
catch (Exception ex)
{
UnlimitedPhysicalStrength.Logger.LogError((object)("设置自定义最大体力时出错: " + ex.Message));
}
}
}
internal static void ApplyInfiniteStamina(object playerInstance)
{
if (playerInstance == null)
{
return;
}
UnlimitedPhysicalStrength.SetPlayerController(playerInstance);
Type type = playerInstance.GetType();
FieldInfo fieldInfo = null;
FieldInfo fieldInfo2 = null;
string[] array = new string[6] { "EnergyCurrent", "energyCurrent", "stamina", "Stamina", "currentEnergy", "CurrentEnergy" };
string[] array2 = new string[6] { "EnergyStart", "energyStart", "maxStamina", "MaxStamina", "maxEnergy", "MaxEnergy" };
string[] array3 = array;
foreach (string name in array3)
{
fieldInfo = type.GetField(name, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
if (fieldInfo != null)
{
break;
}
}
string[] array4 = array2;
foreach (string name2 in array4)
{
fieldInfo2 = type.GetField(name2, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
if (fieldInfo2 != null)
{
break;
}
}
if (fieldInfo == null || fieldInfo2 == null)
{
PropertyInfo propertyInfo = null;
PropertyInfo propertyInfo2 = null;
string[] array5 = array;
foreach (string name3 in array5)
{
propertyInfo = type.GetProperty(name3, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
if (propertyInfo != null)
{
break;
}
}
string[] array6 = array2;
foreach (string name4 in array6)
{
propertyInfo2 = type.GetProperty(name4, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
if (propertyInfo2 != null)
{
break;
}
}
if (propertyInfo != null && propertyInfo2 != null)
{
float num = (float)propertyInfo2.GetValue(playerInstance);
propertyInfo.SetValue(playerInstance, num);
if (UnlimitedPhysicalStrength.DebugMode && Time.frameCount % 60 == 0)
{
UnlimitedPhysicalStrength.Logger.LogDebug((object)$"Set stamina to max via property: {num}");
}
}
return;
}
float num2 = (float)fieldInfo2.GetValue(playerInstance);
fieldInfo.SetValue(playerInstance, num2);
float num3 = (float)fieldInfo.GetValue(playerInstance);
if (Mathf.Abs(num3 - lastDetectedStamina) > 0.1f || Mathf.Abs(num2 - lastMaxStamina) > 0.1f)
{
if (UnlimitedPhysicalStrength.DebugMode)
{
UnlimitedPhysicalStrength.Logger.LogDebug((object)$"Stamina: {num3}/{num2}");
}
lastDetectedStamina = num3;
lastMaxStamina = num2;
}
if (UnlimitedPhysicalStrength.NoStaminaDrainEnabled)
{
ResetStaminaDrainVariables(playerInstance, type);
}
if (UnlimitedPhysicalStrength.AutoRegenEnabled)
{
ForceStaminaRegeneration(playerInstance, type);
}
}
private static void ResetStaminaDrainVariables(object instance, Type type)
{
try
{
FieldInfo[] fields = type.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
FieldInfo[] array = fields;
foreach (FieldInfo fieldInfo in array)
{
string text = fieldInfo.Name.ToLower();
if (text.Contains("drain") || text.Contains("cost") || text.Contains("consume") || text.Contains("消耗"))
{
if (fieldInfo.FieldType == typeof(float))
{
fieldInfo.SetValue(instance, 0f);
}
else if (fieldInfo.FieldType == typeof(int))
{
fieldInfo.SetValue(instance, 0);
}
}
}
}
catch
{
}
}
private static void ForceStaminaRegeneration(object instance, Type type)
{
try
{
if (UnlimitedPhysicalStrength.InstantStaminaRecoveryEnabled)
{
return;
}
FieldInfo[] fields = type.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
FieldInfo[] array = fields;
foreach (FieldInfo fieldInfo in array)
{
string text = fieldInfo.Name.ToLower();
if ((text.Contains("regen") || text.Contains("recovery") || text.Contains("recover") || text.Contains("回复")) && fieldInfo.FieldType == typeof(float))
{
float num = (float)fieldInfo.GetValue(instance);
if (num < 100f)
{
fieldInfo.SetValue(instance, 100f);
}
}
}
}
catch
{
}
}
}
[HarmonyPatch]
public static class StaminaSetterInterceptor
{
[HarmonyTargetMethods]
private static IEnumerable<MethodBase> TargetSetterMethods()
{
List<MethodBase> list = new List<MethodBase>();
if (PlayerStaminaController.playerControllerType != null)
{
MethodInfo[] methods = PlayerStaminaController.playerControllerType.GetMethods(BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
MethodInfo[] array = methods;
foreach (MethodInfo methodInfo in array)
{
string text = methodInfo.Name.ToLower();
if (text.StartsWith("set_") && (text.Contains("energy") || text.Contains("stamina")))
{
list.Add(methodInfo);
}
else if (text.Contains("setenergy") || text.Contains("setstamina") || text.Contains("changeenergy") || text.Contains("changestamina") || text.Contains("modify") || text.Contains("adjust"))
{
list.Add(methodInfo);
}
}
}
UnlimitedPhysicalStrength.Logger.LogInfo((object)$"Found {list.Count} stamina setter methods to intercept");
return list;
}
[HarmonyPrefix]
private static bool Prefix(ref object __instance, ref object __0)
{
if (!UnlimitedPhysicalStrength.IsModEnabled || !UnlimitedPhysicalStrength.BlockOtherModsEnabled)
{
return true;
}
try
{
object obj = __0;
if (obj is float)
{
float num = (float)obj;
if (true && UnlimitedPhysicalStrength.InfiniteStaminaEnabled)
{
float effectiveMaxStamina = UnlimitedPhysicalStrength.GetEffectiveMaxStamina();
if (num < effectiveMaxStamina - 0.1f)
{
__0 = effectiveMaxStamina;
if (UnlimitedPhysicalStrength.DebugMode)
{
UnlimitedPhysicalStrength.Logger.LogDebug((object)$"Intercepted stamina reduction: {num} -> {effectiveMaxStamina}");
}
}
}
}
}
catch (Exception ex)
{
if (UnlimitedPhysicalStrength.DebugMode)
{
UnlimitedPhysicalStrength.Logger.LogError((object)("Error intercepting stamina setter: " + ex.Message));
}
}
return true;
}
[HarmonyPostfix]
private static void Postfix(ref object __instance)
{
if (!UnlimitedPhysicalStrength.IsModEnabled || !UnlimitedPhysicalStrength.InfiniteStaminaEnabled)
{
return;
}
try
{
PlayerStaminaController.ApplyInfiniteStamina(__instance);
}
catch (Exception ex)
{
if (UnlimitedPhysicalStrength.DebugMode)
{
UnlimitedPhysicalStrength.Logger.LogError((object)("Error in stamina setter postfix: " + ex.Message));
}
}
}
}
}
