using System;
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 Microsoft.CodeAnalysis;
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("HealthRegenMod")]
[assembly: AssemblyDescription("Health regeneration mod with god mode and one-shot protection")]
[assembly: AssemblyCompany("hyy")]
[assembly: AssemblyProduct("HealthRegenMod")]
[assembly: AssemblyFileVersion("1.1.4.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.1.4.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 HealthRegenMod
{
public static class HealthRegenAPI
{
public static bool SetMaxHealth(int maxHealth)
{
try
{
if (maxHealth < 1 || maxHealth > 10000000)
{
if (PluginConfig.EnableLogging.Value)
{
Plugin.ModLog.LogError((object)$"SetMaxHealth: Value {maxHealth} out of range (1-10000000)");
}
return false;
}
PluginConfig.MaxHealth.Value = maxHealth;
if (PluginConfig.EnableLogging.Value)
{
Plugin.ModLog.LogInfo((object)$"API: MaxHealth set to {maxHealth}");
}
return true;
}
catch (Exception ex)
{
if (PluginConfig.EnableLogging.Value)
{
Plugin.ModLog.LogError((object)("API: SetMaxHealth error: " + ex.Message));
}
return false;
}
}
public static int GetMaxHealth()
{
return PluginConfig.MaxHealth.Value;
}
public static bool SetGodMode(bool enabled)
{
try
{
PluginConfig.EnableGodMode.Value = enabled;
if (PluginConfig.EnableLogging.Value)
{
Plugin.ModLog.LogInfo((object)$"API: GodMode set to {enabled}");
}
return true;
}
catch (Exception ex)
{
if (PluginConfig.EnableLogging.Value)
{
Plugin.ModLog.LogError((object)("API: SetGodMode error: " + ex.Message));
}
return false;
}
}
public static bool GetGodMode()
{
return PluginConfig.EnableGodMode.Value;
}
public static bool SetHealthRegenRate(int regenAmount)
{
try
{
if (regenAmount < 0 || regenAmount > 1000)
{
if (PluginConfig.EnableLogging.Value)
{
Plugin.ModLog.LogError((object)$"SetHealthRegenRate: Value {regenAmount} out of range (0-1000)");
}
return false;
}
PluginConfig.HealthRegenPerFrame.Value = regenAmount;
if (PluginConfig.EnableLogging.Value)
{
Plugin.ModLog.LogInfo((object)$"API: HealthRegenRate set to {regenAmount}");
}
return true;
}
catch (Exception ex)
{
if (PluginConfig.EnableLogging.Value)
{
Plugin.ModLog.LogError((object)("API: SetHealthRegenRate error: " + ex.Message));
}
return false;
}
}
public static int GetHealthRegenRate()
{
return PluginConfig.HealthRegenPerFrame.Value;
}
public static bool SetPlayerHealth(int health)
{
try
{
Type type = Type.GetType("PlayerHealth, Assembly-CSharp");
if (type == null)
{
if (PluginConfig.EnableLogging.Value)
{
Plugin.ModLog.LogError((object)"API: PlayerHealth type not found");
}
return false;
}
Object val = Object.FindObjectOfType(type);
if (val == (Object)null)
{
if (PluginConfig.EnableLogging.Value)
{
Plugin.ModLog.LogError((object)"API: PlayerHealth instance not found");
}
return false;
}
FieldInfo field = type.GetField("health", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
if (field == null)
{
if (PluginConfig.EnableLogging.Value)
{
Plugin.ModLog.LogError((object)"API: health field not found");
}
return false;
}
field.SetValue(val, health);
if (PluginConfig.EnableLogging.Value)
{
Plugin.ModLog.LogInfo((object)$"API: Player health set to {health}");
}
return true;
}
catch (Exception ex)
{
if (PluginConfig.EnableLogging.Value)
{
Plugin.ModLog.LogError((object)("API: SetPlayerHealth error: " + ex.Message));
}
return false;
}
}
public static int GetPlayerHealth()
{
try
{
Type type = Type.GetType("PlayerHealth, Assembly-CSharp");
if (type == null)
{
return -1;
}
Object val = Object.FindObjectOfType(type);
if (val == (Object)null)
{
return -1;
}
FieldInfo field = type.GetField("health", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
if (field == null)
{
return -1;
}
return (int)field.GetValue(val);
}
catch
{
return -1;
}
}
public static bool SaveConfig()
{
try
{
if (PluginConfig.EnableLogging.Value)
{
Plugin.ModLog.LogInfo((object)"API: Configuration saved");
}
return true;
}
catch (Exception ex)
{
if (PluginConfig.EnableLogging.Value)
{
Plugin.ModLog.LogError((object)("API: SaveConfig error: " + ex.Message));
}
return false;
}
}
}
public static class PluginConfig
{
public static ConfigEntry<bool> EnableLogging { get; private set; }
public static ConfigEntry<bool> EnableGodMode { get; private set; }
public static ConfigEntry<int> MaxHealth { get; private set; }
public static ConfigEntry<int> HealthRegenPerFrame { get; private set; }
public static ConfigEntry<bool> ShowDebugInfo { get; private set; }
public static ConfigEntry<bool> EnableOneShotProtection { get; private set; }
public static ConfigEntry<int> OneShotMinHealth { get; private set; }
public static ConfigEntry<int> MaxSingleDamage { get; private set; }
public static void InitConfig(ConfigFile config)
{
//IL_005f: Unknown result type (might be due to invalid IL or missing references)
//IL_0069: Expected O, but got Unknown
//IL_0090: Unknown result type (might be due to invalid IL or missing references)
//IL_009a: Expected O, but got Unknown
//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
//IL_0103: Expected O, but got Unknown
//IL_012e: Unknown result type (might be due to invalid IL or missing references)
//IL_0138: Expected O, but got Unknown
try
{
EnableLogging = config.Bind<bool>("General", "EnableLogging", false, "Enable logging to the console for debugging purposes");
EnableGodMode = config.Bind<bool>("Gameplay", "EnableGodMode", true, "Enable god mode - health never decreases below max value");
MaxHealth = config.Bind<int>("Gameplay", "MaxHealth", 10000, new ConfigDescription("Maximum health value for the player", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 10000000), Array.Empty<object>()));
HealthRegenPerFrame = config.Bind<int>("Gameplay", "HealthRegenPerFrame", 0, new ConfigDescription("Amount of health regenerated per frame. Set to 0 for instant full heal when god mode is enabled", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 1000), Array.Empty<object>()));
ShowDebugInfo = config.Bind<bool>("UI", "ShowDebugInfo", false, "Show debug information on screen (if supported by the game)");
EnableOneShotProtection = config.Bind<bool>("Protection", "EnableOneShotProtection", true, "Prevent instant death from one-shot kills by limiting maximum damage taken");
OneShotMinHealth = config.Bind<int>("Protection", "OneShotMinHealth", 1, new ConfigDescription("Minimum health to remain after taking massive damage (only works when one-shot protection is enabled)", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 1000), Array.Empty<object>()));
MaxSingleDamage = config.Bind<int>("Protection", "MaxSingleDamage", 500, new ConfigDescription("Maximum damage that can be taken in a single hit. Damage exceeding this will be reduced (0 = unlimited)", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 10000), Array.Empty<object>()));
if (EnableLogging.Value)
{
Plugin.ModLog.LogInfo((object)"Configuration initialized successfully");
}
}
catch (Exception ex)
{
Plugin.ModLog.LogError((object)("Failed to initialize configuration: " + ex.Message));
throw;
}
}
}
[BepInPlugin("hyy.HealthRegenMod", "HealthRegenMod", "1.1.4")]
[BepInProcess("REPO.exe")]
public class Plugin : BaseUnityPlugin
{
internal static ManualLogSource ModLog;
private static Harmony _harmony;
private void Awake()
{
//IL_001e: Unknown result type (might be due to invalid IL or missing references)
//IL_0028: Expected O, but got Unknown
ModLog = ((BaseUnityPlugin)this).Logger;
try
{
PluginConfig.InitConfig(((BaseUnityPlugin)this).Config);
_harmony = new Harmony("hyy.HealthRegenMod");
_harmony.PatchAll(Assembly.GetExecutingAssembly());
if (PluginConfig.EnableLogging.Value)
{
ModLog.LogInfo((object)"HealthRegenMod loaded successfully!");
ModLog.LogInfo((object)$"Configuration loaded - MaxHealth: {PluginConfig.MaxHealth.Value}, GodMode: {PluginConfig.EnableGodMode.Value}, RegenPerFrame: {PluginConfig.HealthRegenPerFrame.Value}");
ModLog.LogInfo((object)$"OneShotProtection: {PluginConfig.EnableOneShotProtection.Value}, MinHealth: {PluginConfig.OneShotMinHealth.Value}, MaxDamage: {PluginConfig.MaxSingleDamage.Value}");
ModLog.LogInfo((object)"author: lingzhu");
ModLog.LogInfo((object)"version: 1.1.4");
ModLog.LogInfo((object)"==========================================");
}
}
catch (Exception ex)
{
ModLog.LogError((object)("Load error: " + ex.Message));
}
}
}
[HarmonyPatch(typeof(PlayerHealth), "Start")]
public class SetMaxHealthPatch
{
private static FieldInfo maxHealthField;
[HarmonyPostfix]
private static void Postfix(PlayerHealth __instance)
{
try
{
if (!PluginConfig.EnableGodMode.Value)
{
return;
}
if (maxHealthField == null)
{
maxHealthField = typeof(PlayerHealth).GetField("maxHealth", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
}
if (!((Object)(object)__instance != (Object)null) || !(maxHealthField != null))
{
return;
}
int value = PluginConfig.MaxHealth.Value;
int num = (int)maxHealthField.GetValue(__instance);
if (num != value)
{
maxHealthField.SetValue(__instance, value);
if (PluginConfig.EnableLogging.Value)
{
Plugin.ModLog.LogInfo((object)$"Set max health to {value}");
}
}
}
catch (Exception ex)
{
if (PluginConfig.EnableLogging.Value)
{
Plugin.ModLog.LogError((object)("Error in SetMaxHealthPatch: " + ex.Message));
}
}
}
}
[HarmonyPatch(typeof(PlayerHealth), "Update")]
public class KeepHealthAtMaxPatch
{
private static FieldInfo healthField;
private static FieldInfo maxHealthField;
[HarmonyPrefix]
private static void Prefix(PlayerHealth __instance)
{
try
{
if (healthField == null)
{
healthField = typeof(PlayerHealth).GetField("health", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
}
if (maxHealthField == null)
{
maxHealthField = typeof(PlayerHealth).GetField("maxHealth", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
}
if (!((Object)(object)__instance != (Object)null) || !(healthField != null) || !(maxHealthField != null))
{
return;
}
int num = (int)healthField.GetValue(__instance);
int num2 = (int)maxHealthField.GetValue(__instance);
int value = PluginConfig.MaxHealth.Value;
if (num2 != value)
{
maxHealthField.SetValue(__instance, value);
num2 = value;
}
if (PluginConfig.EnableGodMode.Value)
{
if (num < num2)
{
healthField.SetValue(__instance, num2);
if (PluginConfig.EnableLogging.Value)
{
Plugin.ModLog.LogDebug((object)$"God mode active: Health restored to {num2}");
}
}
}
else
{
if (PluginConfig.HealthRegenPerFrame.Value <= 0)
{
return;
}
int value2 = PluginConfig.HealthRegenPerFrame.Value;
int num3 = Mathf.Min(num + value2, num2);
if (num3 != num)
{
healthField.SetValue(__instance, num3);
if (PluginConfig.EnableLogging.Value)
{
Plugin.ModLog.LogDebug((object)$"Health regen: {num} -> {num3} (+{value2})");
}
}
}
}
catch (Exception ex)
{
if (PluginConfig.EnableLogging.Value)
{
Plugin.ModLog.LogError((object)("Error in KeepHealthAtMaxPatch: " + ex.Message));
}
}
}
}
[HarmonyPatch]
public class OneShotProtectionPatch
{
private static MethodBase TargetMethod()
{
try
{
Type typeFromHandle = typeof(PlayerHealth);
string[] array = new string[6] { "TakeDamage", "Damage", "ApplyDamage", "OnDamage", "ReceiveDamage", "Hit" };
string[] array2 = array;
foreach (string value in array2)
{
MethodInfo[] methods = typeFromHandle.GetMethods(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
MethodInfo[] array3 = methods;
foreach (MethodInfo methodInfo in array3)
{
if (!methodInfo.Name.Equals(value, StringComparison.OrdinalIgnoreCase))
{
continue;
}
ParameterInfo[] parameters = methodInfo.GetParameters();
ParameterInfo[] array4 = parameters;
foreach (ParameterInfo parameterInfo in array4)
{
if (parameterInfo.ParameterType == typeof(int) || parameterInfo.ParameterType == typeof(float))
{
if (PluginConfig.EnableLogging.Value)
{
Plugin.ModLog.LogInfo((object)("Found damage method: " + methodInfo.Name));
}
return methodInfo;
}
}
}
}
if (PluginConfig.EnableLogging.Value)
{
Plugin.ModLog.LogWarning((object)"No damage method found in PlayerHealth class");
}
return null;
}
catch (Exception ex)
{
if (PluginConfig.EnableLogging.Value)
{
Plugin.ModLog.LogError((object)("Error finding damage method: " + ex.Message));
}
return null;
}
}
[HarmonyPrefix]
private static bool Prefix(object __instance, ref object __0, ref object __1, ref object __2, ref object __3)
{
try
{
if (PluginConfig.EnableGodMode.Value)
{
return false;
}
if (!PluginConfig.EnableOneShotProtection.Value)
{
return true;
}
int num = 0;
object[] array = new object[4] { __0, __1, __2, __3 };
for (int i = 0; i < array.Length; i++)
{
if (array[i] != null)
{
if (array[i] is int num2)
{
num = num2;
break;
}
if (array[i] is float num3)
{
num = (int)num3;
break;
}
}
}
if (num <= 0)
{
return true;
}
int num4 = num;
int value = PluginConfig.MaxSingleDamage.Value;
int value2 = PluginConfig.OneShotMinHealth.Value;
if (value > 0 && num > value)
{
num = value;
if (PluginConfig.EnableLogging.Value)
{
Plugin.ModLog.LogInfo((object)$"One-shot protection: Reduced damage from {num4} to {value}");
}
}
FieldInfo field = typeof(PlayerHealth).GetField("health", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
FieldInfo field2 = typeof(PlayerHealth).GetField("maxHealth", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
if (field != null && __instance != null)
{
int num5 = (int)field.GetValue(__instance);
int value3 = PluginConfig.MaxHealth.Value;
if (field2 != null)
{
value3 = (int)field2.GetValue(__instance);
}
int num6 = num5 - num;
if (num6 < value2 && num6 > 0)
{
num = num5 - value2;
if (PluginConfig.EnableLogging.Value)
{
Plugin.ModLog.LogInfo((object)$"One-shot protection: Adjusted damage to keep minimum {value2} health");
}
}
else if (num6 <= 0)
{
num = 0;
if (PluginConfig.EnableLogging.Value)
{
Plugin.ModLog.LogInfo((object)$"One-shot protection: Prevented fatal damage, kept {num5} health");
}
}
}
if (__0 is int)
{
__0 = num;
}
else if (__0 is float)
{
__0 = (float)num;
}
else if (__1 is int)
{
__1 = num;
}
else if (__1 is float)
{
__1 = (float)num;
}
else if (__2 is int)
{
__2 = num;
}
else if (__2 is float)
{
__2 = (float)num;
}
else if (__3 is int)
{
__3 = num;
}
else if (__3 is float)
{
__3 = (float)num;
}
return true;
}
catch (Exception ex)
{
if (PluginConfig.EnableLogging.Value)
{
Plugin.ModLog.LogError((object)("Error in OneShotProtectionPatch: " + ex.Message));
}
return true;
}
}
}
}
