using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Configuration;
using HarmonyLib;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("Magical")]
[assembly: AssemblyDescription("Magical")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("Crystal")]
[assembly: AssemblyProduct("Magical")]
[assembly: AssemblyCopyright("Copyright © 2023 Crystal Ferrai")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("1414a5c1-1a42-448f-8f27-000b965fcb46")]
[assembly: AssemblyFileVersion("1.0.3.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: AssemblyVersion("1.0.3.0")]
namespace Magical;
[BepInPlugin("dev.crystal.magical", "Magical", "1.0.3.0")]
[BepInProcess("valheim.exe")]
[BepInProcess("valheim_server.exe")]
public class MagicalPlugin : BaseUnityPlugin
{
[HarmonyPatch(typeof(Player))]
private static class Player_Tracking_Patches
{
[HarmonyPatch("Awake")]
[HarmonyPostfix]
private static void Awake_Prefix(Player __instance)
{
SetPlayerValues(__instance);
sPlayers.Add(__instance);
}
[HarmonyPatch("OnDestroy")]
[HarmonyPrefix]
private static void OnDestroy_Prefix(Player __instance)
{
sPlayers.Remove(__instance);
}
}
[HarmonyPatch(typeof(Player))]
private static class Player_Patches
{
private enum TranspilerState
{
Searching,
Checking,
Replacing,
Searching2,
Checking2,
Replacing2,
Finishing
}
[CompilerGenerated]
private sealed class <GetTotalFoodValue_Transpiler>d__2 : IEnumerable<CodeInstruction>, IEnumerable, IEnumerator<CodeInstruction>, IDisposable, IEnumerator
{
private int <>1__state;
private CodeInstruction <>2__current;
private int <>l__initialThreadId;
private IEnumerable<CodeInstruction> instructions;
public IEnumerable<CodeInstruction> <>3__instructions;
private TranspilerState <state>5__2;
private IEnumerator<CodeInstruction> <>7__wrap2;
private CodeInstruction <instruction>5__4;
CodeInstruction IEnumerator<CodeInstruction>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <GetTotalFoodValue_Transpiler>d__2(int <>1__state)
{
this.<>1__state = <>1__state;
<>l__initialThreadId = Environment.CurrentManagedThreadId;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
int num = <>1__state;
if (num == -3 || (uint)(num - 1) <= 3u)
{
try
{
}
finally
{
<>m__Finally1();
}
}
<>7__wrap2 = null;
<instruction>5__4 = null;
<>1__state = -2;
}
private bool MoveNext()
{
//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
//IL_00fc: Expected O, but got Unknown
try
{
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
<state>5__2 = TranspilerState.Searching;
<>7__wrap2 = instructions.GetEnumerator();
<>1__state = -3;
goto IL_015d;
case 1:
<>1__state = -3;
goto IL_0156;
case 2:
<>1__state = -3;
<>2__current = <instruction>5__4;
<>1__state = 3;
return true;
case 3:
<>1__state = -3;
<state>5__2 = TranspilerState.Finishing;
goto IL_0156;
case 4:
{
<>1__state = -3;
goto IL_0156;
}
IL_015d:
if (<>7__wrap2.MoveNext())
{
<instruction>5__4 = <>7__wrap2.Current;
switch (<state>5__2)
{
case TranspilerState.Searching:
if (<instruction>5__4.opcode == OpCodes.Ldc_R4 && (float)<instruction>5__4.operand == 0f)
{
<state>5__2 = TranspilerState.Replacing;
break;
}
<>2__current = <instruction>5__4;
<>1__state = 1;
return true;
case TranspilerState.Replacing:
<>2__current = new CodeInstruction(OpCodes.Ldc_R4, (object)BaseEitr.Value);
<>1__state = 2;
return true;
case TranspilerState.Finishing:
<>2__current = <instruction>5__4;
<>1__state = 4;
return true;
}
goto IL_0156;
}
<>m__Finally1();
<>7__wrap2 = null;
return false;
IL_0156:
<instruction>5__4 = null;
goto IL_015d;
}
}
catch
{
//try-fault
((IDisposable)this).Dispose();
throw;
}
}
bool IEnumerator.MoveNext()
{
//ILSpy generated this explicit interface implementation from .override directive in MoveNext
return this.MoveNext();
}
private void <>m__Finally1()
{
<>1__state = -1;
if (<>7__wrap2 != null)
{
<>7__wrap2.Dispose();
}
}
[DebuggerHidden]
void IEnumerator.Reset()
{
throw new NotSupportedException();
}
[DebuggerHidden]
IEnumerator<CodeInstruction> IEnumerable<CodeInstruction>.GetEnumerator()
{
<GetTotalFoodValue_Transpiler>d__2 <GetTotalFoodValue_Transpiler>d__;
if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
{
<>1__state = 0;
<GetTotalFoodValue_Transpiler>d__ = this;
}
else
{
<GetTotalFoodValue_Transpiler>d__ = new <GetTotalFoodValue_Transpiler>d__2(0);
}
<GetTotalFoodValue_Transpiler>d__.instructions = <>3__instructions;
return <GetTotalFoodValue_Transpiler>d__;
}
[DebuggerHidden]
IEnumerator IEnumerable.GetEnumerator()
{
return ((IEnumerable<CodeInstruction>)this).GetEnumerator();
}
}
[CompilerGenerated]
private sealed class <UpdateFood_Transpiler>d__1 : IEnumerable<CodeInstruction>, IEnumerable, IEnumerator<CodeInstruction>, IDisposable, IEnumerator
{
private int <>1__state;
private CodeInstruction <>2__current;
private int <>l__initialThreadId;
private IEnumerable<CodeInstruction> instructions;
public IEnumerable<CodeInstruction> <>3__instructions;
private TranspilerState <state>5__2;
private CodeInstruction <previousInstruction>5__3;
private IEnumerator<CodeInstruction> <>7__wrap3;
private CodeInstruction <instruction>5__5;
CodeInstruction IEnumerator<CodeInstruction>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <UpdateFood_Transpiler>d__1(int <>1__state)
{
this.<>1__state = <>1__state;
<>l__initialThreadId = Environment.CurrentManagedThreadId;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
int num = <>1__state;
if (num == -3 || (uint)(num - 1) <= 10u)
{
try
{
}
finally
{
<>m__Finally1();
}
}
<previousInstruction>5__3 = null;
<>7__wrap3 = null;
<instruction>5__5 = null;
<>1__state = -2;
}
private bool MoveNext()
{
//IL_0199: Unknown result type (might be due to invalid IL or missing references)
//IL_01a3: Expected O, but got Unknown
//IL_02e8: Unknown result type (might be due to invalid IL or missing references)
//IL_02f2: Expected O, but got Unknown
try
{
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
<state>5__2 = TranspilerState.Searching;
<previousInstruction>5__3 = null;
<>7__wrap3 = instructions.GetEnumerator();
<>1__state = -3;
goto IL_037b;
case 1:
<>1__state = -3;
goto IL_0374;
case 2:
<>1__state = -3;
<state>5__2 = TranspilerState.Searching;
goto IL_0374;
case 3:
<>1__state = -3;
<>2__current = <instruction>5__5;
<>1__state = 4;
return true;
case 4:
<>1__state = -3;
<state>5__2 = TranspilerState.Searching2;
goto IL_0374;
case 5:
<>1__state = -3;
goto IL_0374;
case 6:
<>1__state = -3;
<>2__current = <instruction>5__5;
<>1__state = 7;
return true;
case 7:
<>1__state = -3;
<state>5__2 = TranspilerState.Searching2;
goto IL_0374;
case 8:
<>1__state = -3;
<>2__current = <previousInstruction>5__3;
<>1__state = 9;
return true;
case 9:
<>1__state = -3;
<>2__current = <instruction>5__5;
<>1__state = 10;
return true;
case 10:
<>1__state = -3;
<state>5__2 = TranspilerState.Finishing;
goto IL_0374;
case 11:
{
<>1__state = -3;
goto IL_0374;
}
IL_037b:
if (<>7__wrap3.MoveNext())
{
<instruction>5__5 = <>7__wrap3.Current;
switch (<state>5__2)
{
case TranspilerState.Searching:
if (<instruction>5__5.opcode == OpCodes.Ldfld && ((FieldInfo)<instruction>5__5.operand).Name.Equals("m_foodRegenTimer"))
{
<state>5__2 = TranspilerState.Checking;
}
<>2__current = <instruction>5__5;
<>1__state = 1;
return true;
case TranspilerState.Checking:
if (<instruction>5__5.opcode == OpCodes.Ldc_R4 && (float)<instruction>5__5.operand == 10f)
{
<state>5__2 = TranspilerState.Replacing;
break;
}
<>2__current = <instruction>5__5;
<>1__state = 2;
return true;
case TranspilerState.Replacing:
<>2__current = new CodeInstruction(OpCodes.Ldc_R4, (object)HealthRegenTickRate.Value);
<>1__state = 3;
return true;
case TranspilerState.Searching2:
if (<instruction>5__5.opcode == OpCodes.Ldc_R4 && (float)<instruction>5__5.operand == 0f)
{
<previousInstruction>5__3 = <instruction>5__5;
<state>5__2 = TranspilerState.Checking2;
break;
}
<>2__current = <instruction>5__5;
<>1__state = 5;
return true;
case TranspilerState.Checking2:
if (<instruction>5__5.opcode == OpCodes.Stloc_S)
{
<previousInstruction>5__3 = <instruction>5__5;
<state>5__2 = TranspilerState.Replacing2;
break;
}
<>2__current = <previousInstruction>5__3;
<>1__state = 6;
return true;
case TranspilerState.Replacing2:
<>2__current = new CodeInstruction(OpCodes.Ldc_R4, (object)BaseHealthRegen.Value);
<>1__state = 8;
return true;
case TranspilerState.Finishing:
<>2__current = <instruction>5__5;
<>1__state = 11;
return true;
}
goto IL_0374;
}
<>m__Finally1();
<>7__wrap3 = null;
return false;
IL_0374:
<instruction>5__5 = null;
goto IL_037b;
}
}
catch
{
//try-fault
((IDisposable)this).Dispose();
throw;
}
}
bool IEnumerator.MoveNext()
{
//ILSpy generated this explicit interface implementation from .override directive in MoveNext
return this.MoveNext();
}
private void <>m__Finally1()
{
<>1__state = -1;
if (<>7__wrap3 != null)
{
<>7__wrap3.Dispose();
}
}
[DebuggerHidden]
void IEnumerator.Reset()
{
throw new NotSupportedException();
}
[DebuggerHidden]
IEnumerator<CodeInstruction> IEnumerable<CodeInstruction>.GetEnumerator()
{
<UpdateFood_Transpiler>d__1 <UpdateFood_Transpiler>d__;
if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
{
<>1__state = 0;
<UpdateFood_Transpiler>d__ = this;
}
else
{
<UpdateFood_Transpiler>d__ = new <UpdateFood_Transpiler>d__1(0);
}
<UpdateFood_Transpiler>d__.instructions = <>3__instructions;
return <UpdateFood_Transpiler>d__;
}
[DebuggerHidden]
IEnumerator IEnumerable.GetEnumerator()
{
return ((IEnumerable<CodeInstruction>)this).GetEnumerator();
}
}
[IteratorStateMachine(typeof(<UpdateFood_Transpiler>d__1))]
[HarmonyPatch("UpdateFood")]
[HarmonyTranspiler]
private static IEnumerable<CodeInstruction> UpdateFood_Transpiler(IEnumerable<CodeInstruction> instructions)
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <UpdateFood_Transpiler>d__1(-2)
{
<>3__instructions = instructions
};
}
[IteratorStateMachine(typeof(<GetTotalFoodValue_Transpiler>d__2))]
[HarmonyPatch("GetTotalFoodValue")]
[HarmonyTranspiler]
private static IEnumerable<CodeInstruction> GetTotalFoodValue_Transpiler(IEnumerable<CodeInstruction> instructions)
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <GetTotalFoodValue_Transpiler>d__2(-2)
{
<>3__instructions = instructions
};
}
}
[HarmonyPatch(typeof(Attack))]
private static class Attack_Patches
{
private enum TranspilerState
{
Searching,
Replacing,
Finishing
}
[CompilerGenerated]
private sealed class <ReplaceSkillModifier>d__4 : IEnumerable<CodeInstruction>, IEnumerable, IEnumerator<CodeInstruction>, IDisposable, IEnumerator
{
private int <>1__state;
private CodeInstruction <>2__current;
private int <>l__initialThreadId;
private IEnumerable<CodeInstruction> instructions;
public IEnumerable<CodeInstruction> <>3__instructions;
private float newModifier;
public float <>3__newModifier;
private TranspilerState <state>5__2;
private IEnumerator<CodeInstruction> <>7__wrap2;
private CodeInstruction <instruction>5__4;
CodeInstruction IEnumerator<CodeInstruction>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <ReplaceSkillModifier>d__4(int <>1__state)
{
this.<>1__state = <>1__state;
<>l__initialThreadId = Environment.CurrentManagedThreadId;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
int num = <>1__state;
if (num == -3 || (uint)(num - 1) <= 3u)
{
try
{
}
finally
{
<>m__Finally1();
}
}
<>7__wrap2 = null;
<instruction>5__4 = null;
<>1__state = -2;
}
private bool MoveNext()
{
//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
//IL_00fc: Expected O, but got Unknown
try
{
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
<state>5__2 = TranspilerState.Searching;
<>7__wrap2 = instructions.GetEnumerator();
<>1__state = -3;
goto IL_015d;
case 1:
<>1__state = -3;
goto IL_0156;
case 2:
<>1__state = -3;
<>2__current = <instruction>5__4;
<>1__state = 3;
return true;
case 3:
<>1__state = -3;
<state>5__2 = TranspilerState.Finishing;
goto IL_0156;
case 4:
{
<>1__state = -3;
goto IL_0156;
}
IL_015d:
if (<>7__wrap2.MoveNext())
{
<instruction>5__4 = <>7__wrap2.Current;
switch (<state>5__2)
{
case TranspilerState.Searching:
if (<instruction>5__4.opcode == OpCodes.Ldc_R4 && (float)<instruction>5__4.operand == 0.33f)
{
<state>5__2 = TranspilerState.Replacing;
break;
}
<>2__current = <instruction>5__4;
<>1__state = 1;
return true;
case TranspilerState.Replacing:
<>2__current = new CodeInstruction(OpCodes.Ldc_R4, (object)newModifier);
<>1__state = 2;
return true;
case TranspilerState.Finishing:
<>2__current = <instruction>5__4;
<>1__state = 4;
return true;
}
goto IL_0156;
}
<>m__Finally1();
<>7__wrap2 = null;
return false;
IL_0156:
<instruction>5__4 = null;
goto IL_015d;
}
}
catch
{
//try-fault
((IDisposable)this).Dispose();
throw;
}
}
bool IEnumerator.MoveNext()
{
//ILSpy generated this explicit interface implementation from .override directive in MoveNext
return this.MoveNext();
}
private void <>m__Finally1()
{
<>1__state = -1;
if (<>7__wrap2 != null)
{
<>7__wrap2.Dispose();
}
}
[DebuggerHidden]
void IEnumerator.Reset()
{
throw new NotSupportedException();
}
[DebuggerHidden]
IEnumerator<CodeInstruction> IEnumerable<CodeInstruction>.GetEnumerator()
{
<ReplaceSkillModifier>d__4 <ReplaceSkillModifier>d__;
if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
{
<>1__state = 0;
<ReplaceSkillModifier>d__ = this;
}
else
{
<ReplaceSkillModifier>d__ = new <ReplaceSkillModifier>d__4(0);
}
<ReplaceSkillModifier>d__.instructions = <>3__instructions;
<ReplaceSkillModifier>d__.newModifier = <>3__newModifier;
return <ReplaceSkillModifier>d__;
}
[DebuggerHidden]
IEnumerator IEnumerable.GetEnumerator()
{
return ((IEnumerable<CodeInstruction>)this).GetEnumerator();
}
}
[HarmonyPatch("GetAttackStamina")]
[HarmonyTranspiler]
private static IEnumerable<CodeInstruction> GetAttackStamina_Transpiler(IEnumerable<CodeInstruction> instructions)
{
return ReplaceSkillModifier(instructions, SkillStaminaReduction.Value);
}
[HarmonyPatch("GetAttackEitr")]
[HarmonyTranspiler]
private static IEnumerable<CodeInstruction> GetAttackEitr_Transpiler(IEnumerable<CodeInstruction> instructions)
{
return ReplaceSkillModifier(instructions, SkillEitrReduction.Value);
}
[HarmonyPatch("GetAttackHealth")]
[HarmonyTranspiler]
private static IEnumerable<CodeInstruction> GetAttackHealth_Transpiler(IEnumerable<CodeInstruction> instructions)
{
return ReplaceSkillModifier(instructions, SkillHealthReduction.Value);
}
[IteratorStateMachine(typeof(<ReplaceSkillModifier>d__4))]
private static IEnumerable<CodeInstruction> ReplaceSkillModifier(IEnumerable<CodeInstruction> instructions, float newModifier)
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <ReplaceSkillModifier>d__4(-2)
{
<>3__instructions = instructions,
<>3__newModifier = newModifier
};
}
}
public const string ModId = "dev.crystal.magical";
public static ConfigEntry<float> BaseStamina;
public static ConfigEntry<float> BaseEitr;
public static ConfigEntry<float> BaseHealth;
public static ConfigEntry<float> BaseStaminaRegen;
public static ConfigEntry<float> BaseEitrRegen;
public static ConfigEntry<float> BaseHealthRegen;
public static ConfigEntry<float> StaminaRegenDelay;
public static ConfigEntry<float> EitrRegenDelay;
public static ConfigEntry<float> HealthRegenTickRate;
public static ConfigEntry<float> SkillStaminaReduction;
public static ConfigEntry<float> SkillEitrReduction;
public static ConfigEntry<float> SkillHealthReduction;
private static Harmony sPlayerTrackingHarmony;
private static Harmony sPlayerHarmony;
private static Harmony sAttackHarmony;
private static List<Player> sPlayers;
static MagicalPlugin()
{
sPlayers = new List<Player>();
}
private void Awake()
{
//IL_02bd: Unknown result type (might be due to invalid IL or missing references)
//IL_02c7: Expected O, but got Unknown
//IL_02cc: Unknown result type (might be due to invalid IL or missing references)
//IL_02d6: Expected O, but got Unknown
//IL_02db: Unknown result type (might be due to invalid IL or missing references)
//IL_02e5: Expected O, but got Unknown
BaseStamina = ((BaseUnityPlugin)this).Config.Bind<float>("Base", "BaseStamina", 50f, "Maximum stamina before any food modifiers are applied. Game default 50.");
BaseStamina.SettingChanged += PlayerVariable_SettingChanged;
BaseEitr = ((BaseUnityPlugin)this).Config.Bind<float>("Base", "BaseEitr", 0f, "Maximum eitr before any food modifiers are applied. Game default 0.");
BaseEitr.SettingChanged += PlayerConstant_SettingChanged;
BaseHealth = ((BaseUnityPlugin)this).Config.Bind<float>("Base", "BaseHealth", 25f, "Maximum health before any food modifiers are applied. Game default 25.");
BaseHealth.SettingChanged += PlayerVariable_SettingChanged;
BaseStaminaRegen = ((BaseUnityPlugin)this).Config.Bind<float>("Regen", "BaseStaminaRegen", 6f, "The base rate of stamina regen per second, before any modifiers are applied. Game default 6.");
BaseStaminaRegen.SettingChanged += PlayerVariable_SettingChanged;
BaseEitrRegen = ((BaseUnityPlugin)this).Config.Bind<float>("Regen", "BaseEitrRegen", 2f, "The base rate of eitr regen per second, before any modifiers are applied. Game default 2.");
BaseEitrRegen.SettingChanged += PlayerVariable_SettingChanged;
BaseHealthRegen = ((BaseUnityPlugin)this).Config.Bind<float>("Regen", "BaseHealthRegen", 0f, "The base rate of health regen per health regen tick, before any modifiers are applied. Game default 0.");
BaseHealthRegen.SettingChanged += PlayerConstant_SettingChanged;
StaminaRegenDelay = ((BaseUnityPlugin)this).Config.Bind<float>("Regen", "StaminaRegenDelay", 1f, "The number of seconds after using stamina before it starts to regenerate. Game default 1.");
StaminaRegenDelay.SettingChanged += PlayerVariable_SettingChanged;
EitrRegenDelay = ((BaseUnityPlugin)this).Config.Bind<float>("Regen", "EitrRegenDelay", 1f, "The number of seconds after using eitr before it starts to regenerate. Game default 1.");
EitrRegenDelay.SettingChanged += PlayerVariable_SettingChanged;
HealthRegenTickRate = ((BaseUnityPlugin)this).Config.Bind<float>("Regen", "HealthRegenTickRate", 10f, "The number of seconds between ticks of health regeneration. Game default 10.");
HealthRegenTickRate.SettingChanged += PlayerConstant_SettingChanged;
SkillStaminaReduction = ((BaseUnityPlugin)this).Config.Bind<float>("Skill", "SkillStaminaReduction", 0.33f, "Stamina cost reduction multiplier for actions based on player skill. Value represents reduction with 100 skill and will scale down at lower skill levels. Game default 0.33.");
SkillStaminaReduction.SettingChanged += Attack_SettingChanged;
SkillEitrReduction = ((BaseUnityPlugin)this).Config.Bind<float>("Skill", "SkillEitrReduction", 0.33f, "Eitr cost reduction multiplier for actions based on player skill. Value represents reduction with 100 skill and will scale down at lower skill levels. Game default 0.33.");
SkillEitrReduction.SettingChanged += Attack_SettingChanged;
SkillHealthReduction = ((BaseUnityPlugin)this).Config.Bind<float>("Skill", "SkillHealthReduction", 0.33f, "Health cost reduction multiplier for actions based on player skill. Value represents reduction with 100 skill and will scale down at lower skill levels. Game default 0.33.");
SkillHealthReduction.SettingChanged += Attack_SettingChanged;
sPlayerTrackingHarmony = new Harmony("dev.crystal.magical_Player_Tracking");
sPlayerHarmony = new Harmony("dev.crystal.magical_Player");
sAttackHarmony = new Harmony("dev.crystal.magical_Attack");
ClampConfig();
sPlayerTrackingHarmony.PatchAll(typeof(Player_Tracking_Patches));
sPlayerHarmony.PatchAll(typeof(Player_Patches));
sAttackHarmony.PatchAll(typeof(Attack_Patches));
}
private void OnDestroy()
{
sPlayerTrackingHarmony.UnpatchSelf();
sPlayerHarmony.UnpatchSelf();
sAttackHarmony.UnpatchSelf();
sPlayers.Clear();
}
private static void ClampConfig()
{
if (BaseStamina.Value < 0f)
{
BaseStamina.Value = 0f;
}
if (BaseStamina.Value > 1000f)
{
BaseStamina.Value = 1000f;
}
if (BaseEitr.Value < 0f)
{
BaseEitr.Value = 0f;
}
if (BaseEitr.Value > 1000f)
{
BaseEitr.Value = 1000f;
}
if (BaseHealth.Value < 0f)
{
BaseHealth.Value = 0f;
}
if (BaseHealth.Value > 1000f)
{
BaseHealth.Value = 1000f;
}
if (BaseStaminaRegen.Value < 0.1f)
{
BaseStaminaRegen.Value = 0.1f;
}
if (BaseStaminaRegen.Value > 1000f)
{
BaseStaminaRegen.Value = 1000f;
}
if (BaseEitrRegen.Value < 0.1f)
{
BaseEitrRegen.Value = 0.1f;
}
if (BaseEitrRegen.Value > 1000f)
{
BaseEitrRegen.Value = 1000f;
}
if (BaseHealthRegen.Value < 0f)
{
BaseHealthRegen.Value = 0f;
}
if (BaseHealthRegen.Value > 1000f)
{
BaseHealthRegen.Value = 1000f;
}
if (StaminaRegenDelay.Value < 0.1f)
{
StaminaRegenDelay.Value = 0.1f;
}
if (StaminaRegenDelay.Value > 3600f)
{
StaminaRegenDelay.Value = 3600f;
}
if (EitrRegenDelay.Value < 0.1f)
{
EitrRegenDelay.Value = 0.1f;
}
if (EitrRegenDelay.Value > 3600f)
{
EitrRegenDelay.Value = 3600f;
}
if (HealthRegenTickRate.Value < 0.1f)
{
HealthRegenTickRate.Value = 0.1f;
}
if (HealthRegenTickRate.Value > 3600f)
{
HealthRegenTickRate.Value = 3600f;
}
if (SkillStaminaReduction.Value < 0f)
{
SkillStaminaReduction.Value = 0f;
}
if (SkillStaminaReduction.Value > 1f)
{
SkillStaminaReduction.Value = 1f;
}
if (SkillEitrReduction.Value < 0f)
{
SkillEitrReduction.Value = 0f;
}
if (SkillEitrReduction.Value > 1f)
{
SkillEitrReduction.Value = 1f;
}
if (SkillHealthReduction.Value < 0f)
{
SkillHealthReduction.Value = 0f;
}
if (SkillHealthReduction.Value > 1f)
{
SkillHealthReduction.Value = 1f;
}
}
private void PlayerVariable_SettingChanged(object sender, EventArgs e)
{
ClampConfig();
foreach (Player sPlayer in sPlayers)
{
SetPlayerValues(sPlayer);
}
}
private void Attack_SettingChanged(object sender, EventArgs e)
{
ClampConfig();
sAttackHarmony.UnpatchSelf();
sAttackHarmony.PatchAll(typeof(Attack_Patches));
}
private void PlayerConstant_SettingChanged(object sender, EventArgs e)
{
ClampConfig();
sPlayerHarmony.UnpatchSelf();
sPlayerHarmony.PatchAll(typeof(Player_Patches));
}
private static void SetPlayerValues(Player player)
{
player.m_baseStamina = BaseStamina.Value;
player.m_baseHP = BaseHealth.Value;
player.m_staminaRegen = BaseStaminaRegen.Value;
player.m_eiterRegen = BaseEitrRegen.Value;
player.m_staminaRegenDelay = StaminaRegenDelay.Value;
player.m_eitrRegenDelay = EitrRegenDelay.Value;
}
}
