using System;
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 BepInEx.Logging;
using BetterStamina;
using HarmonyLib;
using UnityEngine;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("BetterStamina")]
[assembly: AssemblyDescription("Rebalances stamina system to make it more forgiving and improve the combat flow.")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("BetterStamina")]
[assembly: AssemblyCopyright("Copyright © bakaspaceman 2021-2023")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("c78b697c-0617-40b5-b559-88d31b5ed1a8")]
[assembly: AssemblyFileVersion("2.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.6.2", FrameworkDisplayName = ".NET Framework 4.6.2")]
[assembly: AssemblyVersion("2.0.0.0")]
internal static class StatusEffectPatches
{
private static void UpdateStatusEffect(StatusEffect se, bool onPlayer = false)
{
string text = (onPlayer ? " on local player " : " in ObjectDB ");
SE_Stats val = (SE_Stats)(object)((se is SE_Stats) ? se : null);
if (val != null)
{
switch (se.m_name)
{
case "$se_cold_name":
BepInPluginTemplate.DebugLog($"[{Localization.instance.Localize(se.m_name)}] Updating m_staminaRegenMultiplier{text}from {val.m_staminaRegenMultiplier} to {BetterStaminaPlugin.coldStaminaRegenMultiplier.Value}");
val.m_staminaRegenMultiplier = BetterStaminaPlugin.coldStaminaRegenMultiplier.Value;
break;
case "$se_wet_name":
BepInPluginTemplate.DebugLog($"[{Localization.instance.Localize(se.m_name)}] Updating m_staminaRegenMultiplier{text}from {val.m_staminaRegenMultiplier} to {BetterStaminaPlugin.wetStaminaRegenMultiplier.Value}");
val.m_staminaRegenMultiplier = BetterStaminaPlugin.wetStaminaRegenMultiplier.Value;
break;
case "$se_rested_name":
{
BepInPluginTemplate.DebugLog($"[{Localization.instance.Localize(se.m_name)}] Updating m_staminaRegenMultiplier{text}from {val.m_staminaRegenMultiplier} to {BetterStaminaPlugin.restedStaminaRegenMultiplier.Value}");
val.m_staminaRegenMultiplier = BetterStaminaPlugin.restedStaminaRegenMultiplier.Value;
SE_Rested val2 = (SE_Rested)(object)((se is SE_Rested) ? se : null);
BepInPluginTemplate.DebugLog($"[{Localization.instance.Localize(se.m_name)}] Updating m_TTLPerComfortLevel{text}from {val2.m_TTLPerComfortLevel} to {BetterStaminaPlugin.restedDurationPerComfortLvl.Value}");
val2.m_TTLPerComfortLevel = BetterStaminaPlugin.restedDurationPerComfortLvl.Value;
break;
}
}
}
}
public static void UpdateEffects(ObjectDB __instance)
{
foreach (StatusEffect statusEffect in __instance.m_StatusEffects)
{
if (statusEffect is SE_Stats)
{
UpdateStatusEffect(statusEffect);
}
}
}
[HarmonyPatch(typeof(ObjectDB), "Awake")]
[HarmonyPostfix]
public static void ObjectDBAwake_PostFix(ObjectDB __instance)
{
UpdateEffects(__instance);
}
[HarmonyPatch(typeof(Player), "SetLocalPlayer")]
[HarmonyPostfix]
public static void SetLocalPlayerPostFix(Player __instance, SEMan ___m_seman)
{
if (!((Object)(object)__instance != (Object)null) || ___m_seman == null)
{
return;
}
foreach (StatusEffect item in (List<StatusEffect>)BetterStaminaPlugin.statusEffectsField.GetValue(___m_seman))
{
UpdateStatusEffect(item, onPlayer: true);
}
}
}
internal static class SkillPatches
{
private static float defaultBlockStaminaDrain;
private static float defaultSneakStaminaDrain;
private static float defaultStaminaUsage;
private static float defaultJumpStaminaUsage;
[HarmonyPatch(typeof(Player), "OnSneaking")]
[HarmonyPrefix]
private static void OnSneaking_Prefix(Player __instance, Skills ___m_skills)
{
defaultSneakStaminaDrain = __instance.m_sneakStaminaDrain;
if (!((Object)(object)Player.m_localPlayer == (Object)null) && !((Object)(object)Player.m_localPlayer != (Object)(object)__instance))
{
float num = EasingFunctions.GetEasingFunction(EasingFunctions.Ease.EaseOutSine)(1f, BetterStaminaPlugin.sneakMaxSkillStaminaCost.Value, ___m_skills.GetSkillFactor((SkillType)100));
__instance.m_sneakStaminaDrain *= num;
if (BetterStaminaPlugin.enableSkillStaminaLogging != null && BetterStaminaPlugin.enableSkillStaminaLogging.Value)
{
BepInPluginTemplate.DebugLog($"OnSneaking: Usage change: {defaultSneakStaminaDrain} - {__instance.m_sneakStaminaDrain}; Mathf.Lerp: {Mathf.Lerp(1f, BetterStaminaPlugin.sneakMaxSkillStaminaCost.Value, ___m_skills.GetSkillFactor((SkillType)100))}; Custom: {num}; skill: {___m_skills.GetSkillFactor((SkillType)100)};");
}
}
}
[HarmonyPatch(typeof(Player), "OnSneaking")]
[HarmonyPostfix]
private static void OnSneaking_PostFix(Player __instance)
{
if (defaultSneakStaminaDrain != 0f)
{
__instance.m_sneakStaminaDrain = defaultSneakStaminaDrain;
}
}
[HarmonyPatch(typeof(Player), "OnJump")]
[HarmonyPrefix]
private static void OnJump_Prefix(Player __instance, Skills ___m_skills)
{
defaultJumpStaminaUsage = ((Character)__instance).m_jumpStaminaUsage;
if (!((Object)(object)Player.m_localPlayer == (Object)null) && !((Object)(object)Player.m_localPlayer != (Object)(object)__instance))
{
float num = EasingFunctions.GetEasingFunction(EasingFunctions.Ease.EaseOutSine)(1f, BetterStaminaPlugin.jumpMaxSkillStaminaCost.Value, ___m_skills.GetSkillFactor((SkillType)100));
((Character)__instance).m_jumpStaminaUsage = ((Character)__instance).m_jumpStaminaUsage * num;
if (BetterStaminaPlugin.enableSkillStaminaLogging != null && BetterStaminaPlugin.enableSkillStaminaLogging.Value)
{
BepInPluginTemplate.DebugLog($"OnJump: Usage change: {defaultJumpStaminaUsage} - {((Character)__instance).m_jumpStaminaUsage}; Mathf.Lerp: {Mathf.Lerp(1f, BetterStaminaPlugin.jumpMaxSkillStaminaCost.Value, ___m_skills.GetSkillFactor((SkillType)100))}; Custom: {num}; skill: {___m_skills.GetSkillFactor((SkillType)100)};");
}
}
}
[HarmonyPatch(typeof(Player), "OnJump")]
[HarmonyPostfix]
private static void OnJump_PostFix(Player __instance)
{
if (defaultJumpStaminaUsage != 0f)
{
((Character)__instance).m_jumpStaminaUsage = defaultJumpStaminaUsage;
}
}
[HarmonyPatch(typeof(Player), "UpdateDodge")]
[HarmonyPrefix]
private static void UpdateDodge_Prefix(Player __instance, Skills ___m_skills, float ___m_queuedDodgeTimer)
{
defaultStaminaUsage = __instance.m_dodgeStaminaUsage;
if (!((Object)(object)Player.m_localPlayer == (Object)null) && !((Object)(object)Player.m_localPlayer != (Object)(object)__instance))
{
float num = EasingFunctions.GetEasingFunction(EasingFunctions.Ease.EaseOutSine)(1f, BetterStaminaPlugin.dodgeMaxSkillStaminaCost.Value, ___m_skills.GetSkillFactor((SkillType)100));
__instance.m_dodgeStaminaUsage *= num;
if (BetterStaminaPlugin.enableSkillStaminaLogging != null && BetterStaminaPlugin.enableSkillStaminaLogging.Value && (double)___m_queuedDodgeTimer > 0.0 && ((Character)__instance).IsOnGround() && !((Character)__instance).IsDead() && !((Character)__instance).InAttack() && !((Character)__instance).IsEncumbered() && !((Character)__instance).InDodge())
{
BepInPluginTemplate.DebugLog($"UpdateDoge: Usage change: {defaultStaminaUsage} - {__instance.m_dodgeStaminaUsage}; Mathf.Lerp: {Mathf.Lerp(1f, BetterStaminaPlugin.dodgeMaxSkillStaminaCost.Value, ___m_skills.GetSkillFactor((SkillType)100))}; Custom: {num}; skill: {___m_skills.GetSkillFactor((SkillType)100)};");
}
}
}
[HarmonyPatch(typeof(Player), "UpdateDodge")]
[HarmonyPostfix]
private static void UpdateDodge_PostFix(Player __instance)
{
if (defaultStaminaUsage != 0f)
{
__instance.m_dodgeStaminaUsage = defaultStaminaUsage;
}
}
[HarmonyPatch(typeof(Humanoid), "BlockAttack")]
[HarmonyPrefix]
private static void BlockAttack_Prefix(Humanoid __instance)
{
//IL_003a: Unknown result type (might be due to invalid IL or missing references)
//IL_0040: Expected O, but got Unknown
if (!((Object)(object)Player.m_localPlayer != (Object)null) || !((Object)(object)Player.m_localPlayer == (Object)(object)__instance))
{
return;
}
defaultBlockStaminaDrain = __instance.m_blockStaminaDrain;
Skills val = (Skills)BetterStaminaPlugin.playerSkillsField.GetValue(Player.m_localPlayer);
if (!((Object)(object)val == (Object)null))
{
float num = EasingFunctions.GetEasingFunction(EasingFunctions.Ease.EaseOutSine)(1f, BetterStaminaPlugin.blockMaxSkillStaminaCost.Value, val.GetSkillFactor((SkillType)6));
__instance.m_blockStaminaDrain *= num;
if (BetterStaminaPlugin.enableSkillStaminaLogging != null && BetterStaminaPlugin.enableSkillStaminaLogging.Value)
{
BepInPluginTemplate.DebugLog($"BlockAttack: Usage change: {defaultBlockStaminaDrain} - {__instance.m_blockStaminaDrain}; Mathf.Lerp: {Mathf.Lerp(1f, BetterStaminaPlugin.blockMaxSkillStaminaCost.Value, val.GetSkillFactor((SkillType)6))}; Custom: {num}; skill: {val.GetSkillFactor((SkillType)6)};");
}
}
}
[HarmonyPatch(typeof(Humanoid), "BlockAttack")]
[HarmonyPostfix]
private static void BlockAttack_PostFix(Player __instance)
{
if (defaultBlockStaminaDrain != 0f)
{
((Humanoid)__instance).m_blockStaminaDrain = defaultBlockStaminaDrain;
}
}
[HarmonyPatch(typeof(Attack), "GetAttackStamina")]
[HarmonyPrefix]
private static bool GetStaminaUsage_Prefix(Attack __instance, Humanoid ___m_character, float ___m_attackStamina, ItemData ___m_weapon, ref float __result)
{
//IL_0053: 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_0104: 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)
if ((Object)(object)Player.m_localPlayer == (Object)null || (Object)(object)Player.m_localPlayer != (Object)(object)___m_character)
{
return true;
}
if ((double)___m_attackStamina <= 0.0)
{
__result = 0f;
return false;
}
double num = ___m_attackStamina;
float num2 = EasingFunctions.GetEasingFunction(EasingFunctions.Ease.EaseOutSine)(1f, BetterStaminaPlugin.weaponMaxSkillAttackStaminaCost.Value, ((Character)___m_character).GetSkillFactor(___m_weapon.m_shared.m_skillType));
__result = (float)(num * (double)num2);
if (BetterStaminaPlugin.enableSkillStaminaLogging != null && BetterStaminaPlugin.enableSkillStaminaLogging.Value && new StackFrame(2).GetMethod().Name.Contains("Update"))
{
float num3 = (float)(num * (double)(1f - BetterStaminaPlugin.weaponMaxSkillAttackStaminaCost.Value) * (double)((Character)___m_character).GetSkillFactor(___m_weapon.m_shared.m_skillType));
float num4 = (float)(num - (double)num3);
BepInPluginTemplate.DebugLog($"Attack.GetStaminaUsage(): Cost - {__result}; Original: {num4}; Custom: {__result}; skill: {((Character)___m_character).GetSkillFactor(___m_weapon.m_shared.m_skillType)}({___m_weapon.m_shared.m_skillType});");
}
return false;
}
[HarmonyPatch(typeof(ItemData), "GetDrawStaminaDrain")]
[HarmonyPostfix]
private static void GetDrawStaminaDrain_Postfix(SharedData ___m_shared, ref float __result)
{
//IL_0028: Unknown result type (might be due to invalid IL or missing references)
//IL_0089: Unknown result type (might be due to invalid IL or missing references)
//IL_00af: Unknown result type (might be due to invalid IL or missing references)
float drawStaminaDrain = ___m_shared.m_attack.m_drawStaminaDrain;
float num = EasingFunctions.GetEasingFunction(EasingFunctions.Ease.EaseOutSine)(1f, BetterStaminaPlugin.bowMaxSkillHoldStaminaCost.Value, ((Character)Player.m_localPlayer).GetSkillFactor(___m_shared.m_skillType));
float num2 = (__result = drawStaminaDrain * num);
if (BetterStaminaPlugin.enableSkillStaminaLogging != null && BetterStaminaPlugin.enableSkillStaminaLogging.Value)
{
BepInPluginTemplate.DebugLog($"BowHoldStamina: Usage change: {drawStaminaDrain} - {num2}; Mathf.Lerp: {Mathf.Lerp(1f, BetterStaminaPlugin.bowMaxSkillHoldStaminaCost.Value, ((Character)Player.m_localPlayer).GetSkillFactor(___m_shared.m_skillType))}; Custom: {num}; skill: {((Character)Player.m_localPlayer).GetSkillFactor(___m_shared.m_skillType)};");
}
}
public static float GetRunStaminaSkillFactor(float drainMax, float drainMin, float skillFactor, Player playerInst)
{
drainMin = BetterStaminaPlugin.runMaxSkillStaminaCost.Value;
if ((Object)(object)Player.m_localPlayer != (Object)null && (Object)(object)Player.m_localPlayer == (Object)(object)playerInst)
{
if (((Humanoid)playerInst).GetCurrentWeapon() != null && !((object)((Humanoid)playerInst).GetCurrentWeapon()).Equals((object?)((Humanoid)playerInst).m_unarmedWeapon.m_itemData))
{
drainMin = BetterStaminaPlugin.runWithWeapMaxSkillStaminaCost.Value;
}
float num = EasingFunctions.GetEasingFunction(EasingFunctions.Ease.EaseOutSine)(drainMax, drainMin, skillFactor);
if (BetterStaminaPlugin.enableSkillStaminaLogging != null && BetterStaminaPlugin.enableSkillStaminaLogging.Value)
{
BepInPluginTemplate.DebugLog($"RunStamina: Skill factor change: {Mathf.Lerp(drainMax, drainMin, skillFactor)} - {num}");
}
return num;
}
return Mathf.Lerp(drainMax, drainMin, skillFactor);
}
[HarmonyPatch(typeof(Player), "CheckRun")]
[HarmonyTranspiler]
private static IEnumerable<CodeInstruction> CheckRun_Transpiler(IEnumerable<CodeInstruction> instructions)
{
//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
//IL_00e6: Expected O, but got Unknown
//IL_013c: Unknown result type (might be due to invalid IL or missing references)
//IL_0146: Expected O, but got Unknown
BepInPluginTemplate.DebugTranspilerLog("######## CheckRun_Transpiler START ########");
List<CodeInstruction> list = new List<CodeInstruction>(instructions);
for (int i = 0; i < list.Count; i++)
{
CodeInstruction val = list[i];
BepInPluginTemplate.DebugTranspilerLog($"{i} {val}");
if (val.opcode == OpCodes.Call && ((object)val).ToString().Contains("Mathf::Lerp"))
{
int num = i;
BepInPluginTemplate.DebugTranspilerLog($">>> Deleting instruction {num} {((object)list[num]).ToString()}:");
list.RemoveAt(i);
BepInPluginTemplate.DebugTranspilerLog($">>> Inserting instruction at {num}:");
BepInPluginTemplate.DebugTranspilerLog("Old: " + ((object)list[num]).ToString());
list.Insert(num, new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(SkillPatches), "GetRunStaminaSkillFactor", (Type[])null, (Type[])null)));
BepInPluginTemplate.DebugTranspilerLog("New: " + ((object)list[num]).ToString());
BepInPluginTemplate.DebugTranspilerLog($">>> Inserting instruction at {num}:");
BepInPluginTemplate.DebugTranspilerLog("Old: " + ((object)list[num]).ToString());
list.Insert(num, new CodeInstruction(OpCodes.Ldarg_0, (object)null));
BepInPluginTemplate.DebugTranspilerLog("New: " + ((object)list[num]).ToString());
break;
}
}
BepInPluginTemplate.DebugTranspilerLog("");
BepInPluginTemplate.DebugTranspilerLog("#############################################################");
BepInPluginTemplate.DebugTranspilerLog($"######## MODIFIED INSTRUCTIONS - {list.Count} ########");
BepInPluginTemplate.DebugTranspilerLog("#############################################################");
BepInPluginTemplate.DebugTranspilerLog("");
for (int j = 0; j < list.Count; j++)
{
CodeInstruction arg = list[j];
BepInPluginTemplate.DebugTranspilerLog($"{j} {arg}");
}
BepInPluginTemplate.DebugTranspilerLog("######## CheckRun_Transpiler END ########");
BepInPluginTemplate.DebugTranspilerLog("");
return list;
}
public static float GetSwimmingStaminaDrain(float drainMax, float drainMin, float skillFactor, Player playerInst)
{
if ((Object)(object)Player.m_localPlayer != (Object)null && (Object)(object)Player.m_localPlayer == (Object)(object)playerInst)
{
float num = EasingFunctions.GetEasingFunction(EasingFunctions.Ease.EaseOutSine)(BetterStaminaPlugin.swimMaxStaminaCost.Value, BetterStaminaPlugin.swimMinStaminaCost.Value, skillFactor);
if (BetterStaminaPlugin.enableSkillStaminaLogging != null && BetterStaminaPlugin.enableSkillStaminaLogging.Value)
{
BepInPluginTemplate.DebugLog($"SwimStamina: Usage change: {Mathf.Lerp(drainMax, drainMin, skillFactor)} - {num}; skill: {((Character)playerInst).GetSkillFactor((SkillType)103)};");
}
return num;
}
return Mathf.Lerp(drainMax, drainMin, skillFactor);
}
[HarmonyPatch(typeof(Player), "OnSwimming")]
[HarmonyTranspiler]
private static IEnumerable<CodeInstruction> OnSwimming_Transpiler(IEnumerable<CodeInstruction> instructions)
{
//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
//IL_00e6: Expected O, but got Unknown
//IL_013c: Unknown result type (might be due to invalid IL or missing references)
//IL_0146: Expected O, but got Unknown
BepInPluginTemplate.DebugTranspilerLog("######## OnSwimming_Transpiler START ########");
List<CodeInstruction> list = new List<CodeInstruction>(instructions);
for (int i = 0; i < list.Count; i++)
{
CodeInstruction val = list[i];
BepInPluginTemplate.DebugTranspilerLog($"{i} {val}");
if (val.opcode == OpCodes.Call && ((object)val).ToString().Contains("Mathf::Lerp"))
{
int num = i;
BepInPluginTemplate.DebugTranspilerLog($">>> Deleting instruction {num} {((object)list[num]).ToString()}:");
list.RemoveAt(i);
BepInPluginTemplate.DebugTranspilerLog($">>> Inserting instruction at {num}:");
BepInPluginTemplate.DebugTranspilerLog("Old: " + ((object)list[num]).ToString());
list.Insert(num, new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(SkillPatches), "GetSwimmingStaminaDrain", (Type[])null, (Type[])null)));
BepInPluginTemplate.DebugTranspilerLog("New: " + ((object)list[num]).ToString());
BepInPluginTemplate.DebugTranspilerLog($">>> Inserting instruction at {num}:");
BepInPluginTemplate.DebugTranspilerLog("Old: " + ((object)list[num]).ToString());
list.Insert(num, new CodeInstruction(OpCodes.Ldarg_0, (object)null));
BepInPluginTemplate.DebugTranspilerLog("New: " + ((object)list[num]).ToString());
break;
}
}
BepInPluginTemplate.DebugTranspilerLog("");
BepInPluginTemplate.DebugTranspilerLog("#############################################################");
BepInPluginTemplate.DebugTranspilerLog($"######## MODIFIED INSTRUCTIONS - {list.Count} ########");
BepInPluginTemplate.DebugTranspilerLog("#############################################################");
BepInPluginTemplate.DebugTranspilerLog("");
for (int j = 0; j < list.Count; j++)
{
CodeInstruction arg = list[j];
BepInPluginTemplate.DebugTranspilerLog($"{j} {arg}");
}
BepInPluginTemplate.DebugTranspilerLog("######## OnSwimming_Transpiler END ########");
BepInPluginTemplate.DebugTranspilerLog("");
return list;
}
}
internal static class GeneralStaminaPatches
{
private static float defaultEncumberedStaminaDrain;
private static void UpdateEncumberedStaminaDrain(Player __instance)
{
if (BetterStaminaPlugin.removeEncumberedStaminaDrain.Value)
{
if (defaultEncumberedStaminaDrain == 0f)
{
defaultEncumberedStaminaDrain = __instance.m_encumberedStaminaDrain;
}
__instance.m_encumberedStaminaDrain = 0f;
}
else if (defaultEncumberedStaminaDrain != 0f)
{
__instance.m_encumberedStaminaDrain = defaultEncumberedStaminaDrain;
defaultEncumberedStaminaDrain = 0f;
}
}
private static float CalculateNewStamina(Player __instance, bool ___m_wallRunning, float ___m_staminaRegen, float ___m_stamina, SEMan ___m_seman, ref float ___m_staminaRegenTimer, float dt)
{
float num = 1f;
if (((Character)__instance).IsBlocking())
{
num *= 0.8f;
}
if (((((Character)__instance).IsSwimming() && !((Character)__instance).IsOnGround()) || ((Character)__instance).InAttack() || ((Character)__instance).InDodge() || ___m_wallRunning) | ((Character)__instance).IsEncumbered())
{
num = 0f;
}
float maxStamina = ((Character)__instance).GetMaxStamina();
float num2 = (float)(1.0 - (double)___m_stamina / (double)maxStamina);
float num3 = (___m_staminaRegen + num2 * ___m_staminaRegen * __instance.m_staminaRegenTimeMultiplier) * num;
float num4 = 1f;
___m_seman.ModifyStaminaRegen(ref num4);
float num5 = num3 * num4;
___m_staminaRegenTimer -= dt;
float num6 = ___m_stamina;
if ((double)___m_stamina < (double)maxStamina && (double)___m_staminaRegenTimer <= 0.0)
{
num6 = Mathf.Min(maxStamina, ___m_stamina + num5 * dt);
}
float num7 = num6 - ___m_stamina;
if (Mathf.Abs(num7) > 0f)
{
BepInPluginTemplate.DebugLog($"StaminaChangeThisFrame: {num5}(dt-{num7}), base regen - {___m_staminaRegen}; activity mult - {num}; base mult - {__instance.m_staminaRegenTimeMultiplier}; missing mult - {num2}; SE mult - {num4}");
}
return num6;
}
[HarmonyPatch(typeof(Player), "UpdateStats", new Type[] { typeof(float) })]
[HarmonyPrefix]
private static void UpdateStats_Prefix(Player __instance, float dt, SEMan ___m_seman, bool ___m_wallRunning, float ___m_staminaRegen, float ___m_stamina, float ___m_staminaRegenTimer)
{
UpdateEncumberedStaminaDrain(__instance);
__instance.m_staminaRegenTimeMultiplier = ((((Humanoid)__instance).GetCurrentWeapon() != null && !((object)((Humanoid)__instance).GetCurrentWeapon()).Equals((object?)((Humanoid)__instance).m_unarmedWeapon.m_itemData)) ? BetterStaminaPlugin.staminaRegenRateMultiplierWithWeapons.Value : BetterStaminaPlugin.staminaRegenRateMultiplier.Value);
__instance.m_staminaRegenDelay = BetterStaminaPlugin.staminaRegenDelay.Value;
if (BetterStaminaPlugin.enableStaminaRegenLogging != null && BetterStaminaPlugin.enableStaminaRegenLogging.Value)
{
CalculateNewStamina(__instance, ___m_wallRunning, ___m_staminaRegen, ___m_stamina, ___m_seman, ref ___m_staminaRegenTimer, dt);
}
}
}
internal static class DebugStaminaPatches
{
[HarmonyPatch(typeof(Player), "UseStamina")]
[HarmonyPrefix]
private static void UseStamina_Prefix(Player __instance, ref float __state, ref float ___m_stamina)
{
__state = ___m_stamina;
}
[HarmonyPatch(typeof(Player), "UseStamina")]
[HarmonyPostfix]
private static void UseStamina_Postfix(Player __instance, float __state, ref float ___m_stamina)
{
if (BetterStaminaPlugin.enableStaminaLogging != null && BetterStaminaPlugin.enableStaminaLogging.Value && ___m_stamina - __state != 0f)
{
BepInPluginTemplate.DebugLog($"UseStamina(): source - {new StackFrame(2).GetMethod().Name}; change - {___m_stamina - __state}");
}
}
}
internal static class ToolsPatches
{
[HarmonyPatch(typeof(Player), "UseStamina")]
[HarmonyPrefix]
private static bool UseStamina_Prefix(Player __instance, ref float v)
{
if (((Humanoid)__instance).GetCurrentWeapon() != null)
{
string name = new StackFrame(2).GetMethod().Name;
if ((name.Contains("Repair") || name.Contains("UpdatePlacement")) && BetterStaminaPlugin.removeToolStaminaCost.Value)
{
return false;
}
}
return true;
}
}
public class BepInPluginTemplate : BaseUnityPlugin
{
public enum LogMessageType
{
LogInfo,
LogMessage,
LogDebug,
LogWarning,
LogError,
LogFatal
}
public static ConfigEntry<bool> enableLogging;
public static ConfigEntry<bool> enableTranspilerLogging;
protected BepInPlugin BepInAttr { get; set; }
protected static Harmony harmonyInst { get; set; }
protected static BepInPluginTemplate modInst { get; set; }
protected static ManualLogSource Logger { get; set; }
public static void DebugTranspilerLog(object message, LogMessageType msgType = LogMessageType.LogInfo)
{
DebugLog(message, msgType, transpilerlogs: true);
}
public static void DebugLog(object message, LogMessageType msgType = LogMessageType.LogInfo, bool transpilerlogs = false)
{
if (enableLogging != null && enableLogging.Value && (!transpilerlogs || enableTranspilerLogging == null || enableTranspilerLogging.Value))
{
switch (msgType)
{
case LogMessageType.LogMessage:
Logger.LogMessage(message);
break;
case LogMessageType.LogDebug:
Logger.LogDebug(message);
break;
case LogMessageType.LogWarning:
Logger.LogWarning(message);
break;
case LogMessageType.LogError:
Logger.LogError(message);
break;
case LogMessageType.LogFatal:
Logger.LogFatal(message);
break;
default:
Logger.LogInfo(message);
break;
}
}
}
public static void PrintOutInstructions(List<CodeInstruction> instructions)
{
DebugTranspilerLog("");
DebugTranspilerLog("#############################################################");
DebugTranspilerLog($"######## MODIFIED INSTRUCTIONS - {instructions.Count} ########");
DebugTranspilerLog("#############################################################");
DebugTranspilerLog("");
for (int i = 0; i < instructions.Count; i++)
{
CodeInstruction arg = instructions[i];
DebugTranspilerLog($"{i} {arg}");
}
}
protected virtual void Awake()
{
//IL_001c: Unknown result type (might be due to invalid IL or missing references)
//IL_0026: Expected O, but got Unknown
//IL_0046: Unknown result type (might be due to invalid IL or missing references)
//IL_0050: Expected O, but got Unknown
modInst = this;
BepInAttr = (BepInPlugin)Attribute.GetCustomAttribute(((object)this).GetType(), typeof(BepInPlugin));
Logger = Logger.CreateLogSource(BepInAttr.Name);
harmonyInst = new Harmony(BepInAttr.GUID);
DebugLog("Loading..");
}
protected virtual void OnDestroy()
{
if (harmonyInst != null)
{
harmonyInst.UnpatchSelf();
}
DebugLog("Unloading..");
Logger.Sources.Remove((ILogSource)(object)Logger);
}
}
internal static class BepInExHelpers
{
public static ObjectDB FindObjectDB()
{
GameObject val = GameObject.Find("_GameMain");
if ((Object)(object)val != (Object)null)
{
ObjectDB component = val.GetComponent<ObjectDB>();
if ((Object)(object)component != (Object)null)
{
return component;
}
}
return null;
}
}
public static class MathUtils
{
public static string ColorRGBToHexString(int r, int g, int b)
{
return $"#{r:X2}{g:X2}{b:X2}";
}
public static float ConvertRange(float originalStart, float originalEnd, float newStart, float newEnd, float value)
{
double num = (double)(newEnd - newStart) / (double)(originalEnd - originalStart);
return (float)((double)newStart + (double)(value - originalStart) * num);
}
public static float Clamp(float value, float min, float max)
{
if (!(value < min))
{
if (!(value > max))
{
return value;
}
return max;
}
return min;
}
}
public static class EasingFunctions
{
public enum Ease
{
EaseInQuad,
EaseOutQuad,
EaseInOutQuad,
EaseInCubic,
EaseOutCubic,
EaseInOutCubic,
EaseInQuart,
EaseOutQuart,
EaseInOutQuart,
EaseInQuint,
EaseOutQuint,
EaseInOutQuint,
EaseInSine,
EaseOutSine,
EaseInOutSine,
EaseInExpo,
EaseOutExpo,
EaseInOutExpo,
EaseInCirc,
EaseOutCirc,
EaseInOutCirc,
Linear,
Spring,
EaseInBounce,
EaseOutBounce,
EaseInOutBounce,
EaseInBack,
EaseOutBack,
EaseInOutBack,
EaseInElastic,
EaseOutElastic,
EaseInOutElastic
}
public delegate float Function(float s, float e, float v);
private const float NATURAL_LOG_OF_2 = 0.6931472f;
public static float Linear(float start, float end, float value)
{
return Mathf.Lerp(start, end, value);
}
public static float Spring(float start, float end, float value)
{
value = Mathf.Clamp01(value);
value = (Mathf.Sin(value * (float)Math.PI * (0.2f + 2.5f * value * value * value)) * Mathf.Pow(1f - value, 2.2f) + value) * (1f + 1.2f * (1f - value));
return start + (end - start) * value;
}
public static float EaseInQuad(float start, float end, float value)
{
end -= start;
return end * value * value + start;
}
public static float EaseOutQuad(float start, float end, float value)
{
end -= start;
return (0f - end) * value * (value - 2f) + start;
}
public static float EaseInOutQuad(float start, float end, float value)
{
value /= 0.5f;
end -= start;
if (value < 1f)
{
return end * 0.5f * value * value + start;
}
value -= 1f;
return (0f - end) * 0.5f * (value * (value - 2f) - 1f) + start;
}
public static float EaseInCubic(float start, float end, float value)
{
end -= start;
return end * value * value * value + start;
}
public static float EaseOutCubic(float start, float end, float value)
{
value -= 1f;
end -= start;
return end * (value * value * value + 1f) + start;
}
public static float EaseInOutCubic(float start, float end, float value)
{
value /= 0.5f;
end -= start;
if (value < 1f)
{
return end * 0.5f * value * value * value + start;
}
value -= 2f;
return end * 0.5f * (value * value * value + 2f) + start;
}
public static float EaseInQuart(float start, float end, float value)
{
end -= start;
return end * value * value * value * value + start;
}
public static float EaseOutQuart(float start, float end, float value)
{
value -= 1f;
end -= start;
return (0f - end) * (value * value * value * value - 1f) + start;
}
public static float EaseInOutQuart(float start, float end, float value)
{
value /= 0.5f;
end -= start;
if (value < 1f)
{
return end * 0.5f * value * value * value * value + start;
}
value -= 2f;
return (0f - end) * 0.5f * (value * value * value * value - 2f) + start;
}
public static float EaseInQuint(float start, float end, float value)
{
end -= start;
return end * value * value * value * value * value + start;
}
public static float EaseOutQuint(float start, float end, float value)
{
value -= 1f;
end -= start;
return end * (value * value * value * value * value + 1f) + start;
}
public static float EaseInOutQuint(float start, float end, float value)
{
value /= 0.5f;
end -= start;
if (value < 1f)
{
return end * 0.5f * value * value * value * value * value + start;
}
value -= 2f;
return end * 0.5f * (value * value * value * value * value + 2f) + start;
}
public static float EaseInSine(float start, float end, float value)
{
end -= start;
return (0f - end) * Mathf.Cos(value * ((float)Math.PI / 2f)) + end + start;
}
public static float EaseOutSine(float start, float end, float value)
{
end -= start;
return end * Mathf.Sin(value * ((float)Math.PI / 2f)) + start;
}
public static float EaseInOutSine(float start, float end, float value)
{
end -= start;
return (0f - end) * 0.5f * (Mathf.Cos((float)Math.PI * value) - 1f) + start;
}
public static float EaseInExpo(float start, float end, float value)
{
end -= start;
return end * Mathf.Pow(2f, 10f * (value - 1f)) + start;
}
public static float EaseOutExpo(float start, float end, float value)
{
end -= start;
return end * (0f - Mathf.Pow(2f, -10f * value) + 1f) + start;
}
public static float EaseInOutExpo(float start, float end, float value)
{
value /= 0.5f;
end -= start;
if (value < 1f)
{
return end * 0.5f * Mathf.Pow(2f, 10f * (value - 1f)) + start;
}
value -= 1f;
return end * 0.5f * (0f - Mathf.Pow(2f, -10f * value) + 2f) + start;
}
public static float EaseInCirc(float start, float end, float value)
{
end -= start;
return (0f - end) * (Mathf.Sqrt(1f - value * value) - 1f) + start;
}
public static float EaseOutCirc(float start, float end, float value)
{
value -= 1f;
end -= start;
return end * Mathf.Sqrt(1f - value * value) + start;
}
public static float EaseInOutCirc(float start, float end, float value)
{
value /= 0.5f;
end -= start;
if (value < 1f)
{
return (0f - end) * 0.5f * (Mathf.Sqrt(1f - value * value) - 1f) + start;
}
value -= 2f;
return end * 0.5f * (Mathf.Sqrt(1f - value * value) + 1f) + start;
}
public static float EaseInBounce(float start, float end, float value)
{
end -= start;
float num = 1f;
return end - EaseOutBounce(0f, end, num - value) + start;
}
public static float EaseOutBounce(float start, float end, float value)
{
value /= 1f;
end -= start;
if (value < 0.36363637f)
{
return end * (7.5625f * value * value) + start;
}
if (value < 0.72727275f)
{
value -= 0.54545456f;
return end * (7.5625f * value * value + 0.75f) + start;
}
if ((double)value < 0.9090909090909091)
{
value -= 0.8181818f;
return end * (7.5625f * value * value + 0.9375f) + start;
}
value -= 21f / 22f;
return end * (7.5625f * value * value + 63f / 64f) + start;
}
public static float EaseInOutBounce(float start, float end, float value)
{
end -= start;
float num = 1f;
if (value < num * 0.5f)
{
return EaseInBounce(0f, end, value * 2f) * 0.5f + start;
}
return EaseOutBounce(0f, end, value * 2f - num) * 0.5f + end * 0.5f + start;
}
public static float EaseInBack(float start, float end, float value)
{
end -= start;
value /= 1f;
float num = 1.70158f;
return end * value * value * ((num + 1f) * value - num) + start;
}
public static float EaseOutBack(float start, float end, float value)
{
float num = 1.70158f;
end -= start;
value -= 1f;
return end * (value * value * ((num + 1f) * value + num) + 1f) + start;
}
public static float EaseInOutBack(float start, float end, float value)
{
float num = 1.70158f;
end -= start;
value /= 0.5f;
if (value < 1f)
{
num *= 1.525f;
return end * 0.5f * (value * value * ((num + 1f) * value - num)) + start;
}
value -= 2f;
num *= 1.525f;
return end * 0.5f * (value * value * ((num + 1f) * value + num) + 2f) + start;
}
public static float EaseInElastic(float start, float end, float value)
{
end -= start;
float num = 1f;
float num2 = num * 0.3f;
float num3 = 0f;
if (value == 0f)
{
return start;
}
if ((value /= num) == 1f)
{
return start + end;
}
float num4;
if (num3 == 0f || num3 < Mathf.Abs(end))
{
num3 = end;
num4 = num2 / 4f;
}
else
{
num4 = num2 / ((float)Math.PI * 2f) * Mathf.Asin(end / num3);
}
return 0f - num3 * Mathf.Pow(2f, 10f * (value -= 1f)) * Mathf.Sin((value * num - num4) * ((float)Math.PI * 2f) / num2) + start;
}
public static float EaseOutElastic(float start, float end, float value)
{
end -= start;
float num = 1f;
float num2 = num * 0.3f;
float num3 = 0f;
if (value == 0f)
{
return start;
}
if ((value /= num) == 1f)
{
return start + end;
}
float num4;
if (num3 == 0f || num3 < Mathf.Abs(end))
{
num3 = end;
num4 = num2 * 0.25f;
}
else
{
num4 = num2 / ((float)Math.PI * 2f) * Mathf.Asin(end / num3);
}
return num3 * Mathf.Pow(2f, -10f * value) * Mathf.Sin((value * num - num4) * ((float)Math.PI * 2f) / num2) + end + start;
}
public static float EaseInOutElastic(float start, float end, float value)
{
end -= start;
float num = 1f;
float num2 = num * 0.3f;
float num3 = 0f;
if (value == 0f)
{
return start;
}
if ((value /= num * 0.5f) == 2f)
{
return start + end;
}
float num4;
if (num3 == 0f || num3 < Mathf.Abs(end))
{
num3 = end;
num4 = num2 / 4f;
}
else
{
num4 = num2 / ((float)Math.PI * 2f) * Mathf.Asin(end / num3);
}
if (value < 1f)
{
return -0.5f * (num3 * Mathf.Pow(2f, 10f * (value -= 1f)) * Mathf.Sin((value * num - num4) * ((float)Math.PI * 2f) / num2)) + start;
}
return num3 * Mathf.Pow(2f, -10f * (value -= 1f)) * Mathf.Sin((value * num - num4) * ((float)Math.PI * 2f) / num2) * 0.5f + end + start;
}
public static Function GetEasingFunction(Ease easingFunction)
{
return easingFunction switch
{
Ease.EaseInQuad => EaseInQuad,
Ease.EaseOutQuad => EaseOutQuad,
Ease.EaseInOutQuad => EaseInOutQuad,
Ease.EaseInCubic => EaseInCubic,
Ease.EaseOutCubic => EaseOutCubic,
Ease.EaseInOutCubic => EaseInOutCubic,
Ease.EaseInQuart => EaseInQuart,
Ease.EaseOutQuart => EaseOutQuart,
Ease.EaseInOutQuart => EaseInOutQuart,
Ease.EaseInQuint => EaseInQuint,
Ease.EaseOutQuint => EaseOutQuint,
Ease.EaseInOutQuint => EaseInOutQuint,
Ease.EaseInSine => EaseInSine,
Ease.EaseOutSine => EaseOutSine,
Ease.EaseInOutSine => EaseInOutSine,
Ease.EaseInExpo => EaseInExpo,
Ease.EaseOutExpo => EaseOutExpo,
Ease.EaseInOutExpo => EaseInOutExpo,
Ease.EaseInCirc => EaseInCirc,
Ease.EaseOutCirc => EaseOutCirc,
Ease.EaseInOutCirc => EaseInOutCirc,
Ease.Linear => Linear,
Ease.Spring => Spring,
Ease.EaseInBounce => EaseInBounce,
Ease.EaseOutBounce => EaseOutBounce,
Ease.EaseInOutBounce => EaseInOutBounce,
Ease.EaseInBack => EaseInBack,
Ease.EaseOutBack => EaseOutBack,
Ease.EaseInOutBack => EaseInOutBack,
Ease.EaseInElastic => EaseInElastic,
Ease.EaseOutElastic => EaseOutElastic,
Ease.EaseInOutElastic => EaseInOutElastic,
_ => null,
};
}
}
namespace BetterStamina;
[BepInPlugin("bakaSpaceman.BetterStamina", "Better Stamina - Hildirs Request Update", "2.1.0")]
public class BetterStaminaPlugin : BepInPluginTemplate
{
public static ConfigEntry<bool> enableStaminaLogging;
public static ConfigEntry<bool> enableStaminaRegenLogging;
public static ConfigEntry<bool> enableSkillStaminaLogging;
public static ConfigEntry<int> nexusID;
public static ConfigEntry<bool> removeEncumberedStaminaDrain;
public static ConfigEntry<float> staminaRegenRateMultiplier;
public static ConfigEntry<float> staminaRegenRateMultiplierWithWeapons;
public static ConfigEntry<float> staminaRegenDelay;
public static ConfigEntry<bool> removeToolStaminaCost;
public static ConfigEntry<float> runMaxSkillStaminaCost;
public static ConfigEntry<float> runWithWeapMaxSkillStaminaCost;
public static ConfigEntry<float> dodgeMaxSkillStaminaCost;
public static ConfigEntry<float> jumpMaxSkillStaminaCost;
public static ConfigEntry<float> blockMaxSkillStaminaCost;
public static ConfigEntry<float> sneakMaxSkillStaminaCost;
public static ConfigEntry<float> weaponMaxSkillAttackStaminaCost;
public static ConfigEntry<float> bowMaxSkillHoldStaminaCost;
public static ConfigEntry<float> swimMaxStaminaCost;
public static ConfigEntry<float> swimMinStaminaCost;
public static ConfigEntry<float> restedStaminaRegenMultiplier;
public static ConfigEntry<float> restedDurationPerComfortLvl;
public static ConfigEntry<float> wetStaminaRegenMultiplier;
public static ConfigEntry<float> coldStaminaRegenMultiplier;
public static FieldInfo playerSkillsField = typeof(Player).GetField("m_skills", BindingFlags.Instance | BindingFlags.NonPublic);
public static FieldInfo statusEffectsField = typeof(SEMan).GetField("m_statusEffects", BindingFlags.Instance | BindingFlags.NonPublic);
private void SetupConfig()
{
nexusID = ((BaseUnityPlugin)this).Config.Bind<int>("General", "NexusID", 153, "Nexus mod ID for updates");
staminaRegenRateMultiplier = ((BaseUnityPlugin)this).Config.Bind<float>("General", "StaminaRegenRateMod", 1.5f, "1 - Default rate, 1.5 - 50% faster rate, 0.5 - 50% slower, etc.");
staminaRegenRateMultiplierWithWeapons = ((BaseUnityPlugin)this).Config.Bind<float>("General", "StaminaRegenRateModWithWeapons", 1.4f, "This will be used instead of StaminaRegenRateMod if player has weapons equipped. 1 - Default rate, 1.5 - 50% faster rate, 0.5 - 50% slower, etc.");
staminaRegenDelay = ((BaseUnityPlugin)this).Config.Bind<float>("General", "StaminaRegenDelay", 1f, "Time in seconds before stamina starts regenerating. Default value - 1.");
removeEncumberedStaminaDrain = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "RemoveEncumberedStaminaDrain", true, "Prevents stamina drain while encumbered.");
removeToolStaminaCost = ((BaseUnityPlugin)this).Config.Bind<bool>("Tools", "RemoveToolStaminaCost", true, "Using tools to repair/build will not consume stamina.");
runMaxSkillStaminaCost = ((BaseUnityPlugin)this).Config.Bind<float>("Skills", "RunCostAtMaxSkill", 0.4f, "The value is a percentage modifier of the default cost. 1 - default cost, < 1 - reduced cost, > 1 - increased");
runWithWeapMaxSkillStaminaCost = ((BaseUnityPlugin)this).Config.Bind<float>("Skills", "RunWithWeaponsCostAtMaxSkill", 0.5f, "This will be used instead of RunCostModifierAtMaxSkill if player has weapons equipped. The value is a percentage modifier of the default cost. 1 - default cost, < 1 - reduced cost, > 1 - increased");
dodgeMaxSkillStaminaCost = ((BaseUnityPlugin)this).Config.Bind<float>("Skills", "DodgeCostAtMaxSkill", 0.67f, "The value is a percentage modifier of the default cost. 1 - default cost, < 1 - reduced cost, > 1 - increased");
jumpMaxSkillStaminaCost = ((BaseUnityPlugin)this).Config.Bind<float>("Skills", "JumpCostAtMaxSkill", 0.67f, "The value is a percentage modifier of the default cost. 1 - default cost, < 1 - reduced cost, > 1 - increased");
blockMaxSkillStaminaCost = ((BaseUnityPlugin)this).Config.Bind<float>("Skills", "BlockCostAtMaxSkill", 0.67f, "The value is a percentage modifier of the default cost. 1 - default cost, < 1 - reduced cost, > 1 - increased");
sneakMaxSkillStaminaCost = ((BaseUnityPlugin)this).Config.Bind<float>("Skills", "SneakCostAtMaxSkill", 0.67f, "The value is a percentage modifier of the default cost. 1 - default cost, < 1 - reduced cost, > 1 - increased");
weaponMaxSkillAttackStaminaCost = ((BaseUnityPlugin)this).Config.Bind<float>("Skills", "WeaponAttackCostAtMaxSkill", 0.67f, "The value is a percentage modifier of the default cost. 1 - default cost, < 1 - reduced cost, > 1 - increased");
bowMaxSkillHoldStaminaCost = ((BaseUnityPlugin)this).Config.Bind<float>("Skills", "HoldBowCostAtMaxSkill", 0.67f, "The value is a percentage modifier of the default cost. 1 - default cost, < 1 - reduced cost, > 1 - increased");
swimMaxStaminaCost = ((BaseUnityPlugin)this).Config.Bind<float>("Skills", "SwimCostAtMinSkill", 6f, "Swimming stamina cost defined in units at minimum Swim skill.");
swimMinStaminaCost = ((BaseUnityPlugin)this).Config.Bind<float>("Skills", "SwimCostAtMaxSkill", 3f, "Swimming stamina cost defined in units at maximum Swim skill.");
coldStaminaRegenMultiplier = ((BaseUnityPlugin)this).Config.Bind<float>("Status Effects", "ColdStaminaRegenModifier", 0.75f, "Vanilla value - 0.75 (25% penalty)");
restedStaminaRegenMultiplier = ((BaseUnityPlugin)this).Config.Bind<float>("Status Effects", "RestedStaminaRegenModifier", 1.5f, "Vanilla value - 2 (100% bonus)");
restedDurationPerComfortLvl = ((BaseUnityPlugin)this).Config.Bind<float>("Status Effects", "RestedDurationIncreasePerConfortLevel", 60f, "This amount of seconds will be added to the effects duration per comfort level. Vanilla value - 60 seconds");
wetStaminaRegenMultiplier = ((BaseUnityPlugin)this).Config.Bind<float>("Status Effects", "WetStaminaRegenModifier", 0.85f, "Vanilla value - 0.85 (15% penalty)");
}
protected override void Awake()
{
base.Awake();
SetupConfig();
if (BepInPluginTemplate.enableLogging != null && BepInPluginTemplate.enableLogging.Value)
{
BepInPluginTemplate.harmonyInst.PatchAll(typeof(DebugStaminaPatches));
}
BepInPluginTemplate.harmonyInst.PatchAll(typeof(GeneralStaminaPatches));
BepInPluginTemplate.harmonyInst.PatchAll(typeof(ToolsPatches));
BepInPluginTemplate.harmonyInst.PatchAll(typeof(SkillPatches));
BepInPluginTemplate.harmonyInst.PatchAll(typeof(StatusEffectPatches));
}
}
