using System;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Threading.Tasks;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Core.Logging.Interpolation;
using BepInEx.Logging;
using BepInEx.Unity.IL2CPP;
using HarmonyLib;
using Il2CppSystem.Collections.Generic;
using Microsoft.CodeAnalysis;
using SOD.Common;
using StaminaSystem;
using UnityEngine;
using UnityEngine.UI;
using UnityStandardAssets.Characters.FirstPerson;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = ".NET 6.0")]
[assembly: AssemblyCompany("StaminaSystem")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+7bf2506111f48113368162e25beeaaa68ae35a1b")]
[assembly: AssemblyProduct("StaminaSystem")]
[assembly: AssemblyTitle("StaminaSystem")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace Microsoft.CodeAnalysis
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
internal sealed class EmbeddedAttribute : Attribute
{
}
}
namespace System.Runtime.CompilerServices
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
internal sealed class NullableAttribute : Attribute
{
public readonly byte[] NullableFlags;
public NullableAttribute(byte P_0)
{
NullableFlags = new byte[1] { P_0 };
}
public NullableAttribute(byte[] P_0)
{
NullableFlags = P_0;
}
}
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
internal sealed class NullableContextAttribute : Attribute
{
public readonly byte Flag;
public NullableContextAttribute(byte P_0)
{
Flag = P_0;
}
}
}
public static class CustomColors
{
public static Color Transparent => new Color(1f, 1f, 1f, 0f);
public static Color Red => new Color(1f, 0f, 0f, 1f);
public static Color Green => new Color(0f, 1f, 0f, 1f);
}
public class NewGameHandler
{
public static ManualLogSource Logger;
public NewGameHandler()
{
Lib.SaveGame.OnAfterLoad += HandleGameLoaded;
Lib.SaveGame.OnAfterNewGame += HandleNewGameStarted;
}
private void HandleNewGameStarted(object sender, EventArgs e)
{
StaminaBar.isGameLoaded = true;
}
private void HandleGameLoaded(object sender, EventArgs e)
{
StaminaBar.isGameLoaded = true;
}
}
public class PlayerInfoProvider
{
public Vector3 GetPlayerLocation()
{
//IL_0008: Unknown result type (might be due to invalid IL or missing references)
//IL_000d: Unknown result type (might be due to invalid IL or missing references)
//IL_0012: Unknown result type (might be due to invalid IL or missing references)
//IL_0015: Unknown result type (might be due to invalid IL or missing references)
Player instance = Player.Instance;
return Vector3Int.op_Implicit(((Actor)instance).currentNodeCoord);
}
public NewNode PlayerNode()
{
Player instance = Player.Instance;
return ((Actor)instance).currentNode;
}
public bool GetIsRunning()
{
Player instance = Player.Instance;
return ((Actor)instance).isRunning;
}
public void SetIsRunning(bool isRunning)
{
Player instance = Player.Instance;
((Actor)instance).isRunning = isRunning;
}
public bool GetHasJumped()
{
FirstPersonController val = Object.FindObjectOfType<FirstPersonController>();
return val.m_Jump;
}
public bool GetIsJumping()
{
FirstPersonController val = Object.FindObjectOfType<FirstPersonController>();
return val.m_Jumping;
}
public bool GetIsGrounded()
{
Player instance = Player.Instance;
return instance.isGrounded;
}
public float GetMovementRunSpeed()
{
GameplayControls instance = GameplayControls.Instance;
return instance.playerRunSpeed;
}
public void SetMovementRunSpeed(float setMovementRunSpeed)
{
GameplayControls instance = GameplayControls.Instance;
instance.playerRunSpeed = setMovementRunSpeed;
}
public float GetMovementWalkSpeed()
{
GameplayControls instance = GameplayControls.Instance;
return instance.playerWalkSpeed;
}
public void SetMovementWalkSpeed(float setMovementWalkSpeed)
{
GameplayControls instance = GameplayControls.Instance;
instance.playerWalkSpeed = setMovementWalkSpeed;
}
public float GetCurrentHealth()
{
Player instance = Player.Instance;
return ((Actor)instance).currentHealth;
}
public void SetCurrentHealth(float health)
{
Player instance = Player.Instance;
((Actor)instance).currentHealth = health;
}
public bool IsOnDuty()
{
Player instance = Player.Instance;
return ((Actor)instance).isOnDuty;
}
public bool IsCurrentlyInAutoTravel()
{
Player instance = Player.Instance;
return instance.autoTravelActive;
}
public float GetBlackEye()
{
Player instance = Player.Instance;
return ((Human)instance).blackEye;
}
public void SetBlackEye(float amount)
{
Player instance = Player.Instance;
((Human)instance).blackEye = amount;
}
public float GetBlackedOut()
{
Player instance = Player.Instance;
return ((Human)instance).blackedOut;
}
public void SetBlackedOut(float amount)
{
Player instance = Player.Instance;
((Human)instance).blackedOut = amount;
}
public void AddEnergy(float amount)
{
Player instance = Player.Instance;
((Human)instance).AddEnergy(amount);
}
public void AddNourishment(float amount)
{
Player instance = Player.Instance;
((Human)instance).AddNourishment(amount);
}
public Telephone GetAnsweringPhone()
{
Player instance = Player.Instance;
return instance.answeringPhone;
}
public List<NewAddress> ApartmentsOwned()
{
Player instance = Player.Instance;
return instance.apartmentsOwned;
}
}
namespace StaminaSystem
{
public class CreateStaminaBar
{
private static GameObject staminaPanel;
public static void CreateBar()
{
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
//IL_0010: Expected O, but got Unknown
//IL_0081: Unknown result type (might be due to invalid IL or missing references)
//IL_0097: Unknown result type (might be due to invalid IL or missing references)
//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
//IL_00da: Unknown result type (might be due to invalid IL or missing references)
//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
//IL_00f0: Expected O, but got Unknown
//IL_0120: Unknown result type (might be due to invalid IL or missing references)
//IL_0130: Unknown result type (might be due to invalid IL or missing references)
//IL_0140: Unknown result type (might be due to invalid IL or missing references)
//IL_0150: Unknown result type (might be due to invalid IL or missing references)
//IL_016b: Unknown result type (might be due to invalid IL or missing references)
//IL_0194: Unknown result type (might be due to invalid IL or missing references)
//IL_01ab: Unknown result type (might be due to invalid IL or missing references)
//IL_0029: Unknown result type (might be due to invalid IL or missing references)
staminaPanel = new GameObject("StaminaBarBackground");
Canvas val = Object.FindObjectOfType<Canvas>();
if ((Object)(object)val == (Object)null)
{
val = new GameObject("Canvas").AddComponent<Canvas>();
val.renderMode = (RenderMode)0;
((Component)val).gameObject.AddComponent<CanvasScaler>();
((Component)val).gameObject.AddComponent<GraphicRaycaster>();
}
staminaPanel.transform.SetParent(((Component)val).transform);
RectTransform val2 = staminaPanel.AddComponent<RectTransform>();
val2.sizeDelta = new Vector2(0f, 0f);
val2.anchorMin = new Vector2(0.5f, 0f);
val2.anchorMax = new Vector2(0.5f, 0f);
val2.anchoredPosition = new Vector2(0f, 20f);
Image val3 = staminaPanel.AddComponent<Image>();
((Graphic)val3).color = Color.black;
GameObject val4 = new GameObject("StaminaFill");
val4.transform.SetParent(staminaPanel.transform);
StaminaBar.staminaFillRect = val4.AddComponent<RectTransform>();
StaminaBar.staminaFillRect.sizeDelta = new Vector2(500f, 10f);
StaminaBar.staminaFillRect.anchorMin = Vector2.zero;
StaminaBar.staminaFillRect.anchorMax = Vector2.one;
StaminaBar.staminaFillRect.anchoredPosition = Vector2.zero;
StaminaBar.staminaFill = val4.AddComponent<Image>();
((Graphic)StaminaBar.staminaFill).color = StaminaBar.currentColor;
Outline val5 = val4.AddComponent<Outline>();
((Shadow)val5).effectColor = new Color(0f, 0f, 0f, 1f);
((Shadow)val5).effectDistance = new Vector2(4f, 4f);
}
public static void DestroyBar()
{
if ((Object)(object)staminaPanel != (Object)null)
{
Object.Destroy((Object)(object)staminaPanel.gameObject);
StaminaSystem.Logger.LogInfo((object)"Deleted old stamina bar");
}
}
public static void UpdateStamina(float amount)
{
//IL_0068: Unknown result type (might be due to invalid IL or missing references)
StaminaBar.currentStamina += amount;
StaminaBar.currentStamina = Mathf.Clamp(StaminaBar.currentStamina, 0f, StaminaBar.maxStamina);
if (StaminaBar.staminaBarCreated)
{
StaminaBar.staminaFill.fillAmount = StaminaBar.currentStamina / StaminaBar.maxStamina;
float num = StaminaBar.currentStamina / StaminaBar.maxStamina * 500f;
((Graphic)StaminaBar.staminaFill).rectTransform.sizeDelta = new Vector2(num, 10f);
}
}
public static void ResetStamina()
{
//IL_001a: Unknown result type (might be due to invalid IL or missing references)
StaminaBar.currentStamina = StaminaBar.maxStamina;
StaminaBar.staminaFillRect.sizeDelta = new Vector2(500f, 10f);
}
}
[BepInPlugin("StaminaSystem", "StaminaSystem", "1.1.0")]
public class StaminaSystem : BasePlugin
{
public static ManualLogSource Logger;
private Harmony harmony;
public static ConfigEntry<float> staminaDrain;
public static ConfigEntry<float> staminaRegain;
public static ConfigEntry<float> staminaJumpDrain;
public static ConfigEntry<float> minStamToRunJump;
public static ConfigEntry<bool> staminaBar;
public static ConfigEntry<float> staminaDrainMeleeFist;
public static ConfigEntry<float> staminaDrainMeleeWeapon;
public static ConfigEntry<float> staminaDrainBlock;
public static ConfigEntry<float> staminaDrainThrowables;
public static ConfigEntry<float> minStamToAttack;
public override void Load()
{
//IL_01c3: Unknown result type (might be due to invalid IL or missing references)
//IL_01c9: Expected O, but got Unknown
//IL_018d: Unknown result type (might be due to invalid IL or missing references)
//IL_0197: Expected O, but got Unknown
Logger = ((BasePlugin)this).Log;
NewGameHandler newGameHandler = new NewGameHandler();
Logger.LogInfo((object)"Loading Stamina System...");
staminaDrainMeleeFist = ((BasePlugin)this).Config.Bind<float>("Stamina Melee Drain (Fists)", "Drain Amount", -40f, "How much stamina drained by melee attacks with fists.");
staminaDrainMeleeWeapon = ((BasePlugin)this).Config.Bind<float>("Stamina Melee Drain (Weapons)", "Drain Amount", -55f, "How much stamina drained by melee attacks with a weapon.");
staminaDrainThrowables = ((BasePlugin)this).Config.Bind<float>("Stamina Throwables Drain", "Drain Amount", -50f, "How much stamina drained by throwing certain items.");
staminaDrainBlock = ((BasePlugin)this).Config.Bind<float>("Stamina Blocking Drain", "Drain Amount", -10f, "How much stamina drained by blocking.");
staminaDrain = ((BasePlugin)this).Config.Bind<float>("Stamina Drain (Sprinting)", "Drain Speed", -20f, "How fast stamina drains while sprinting.");
staminaRegain = ((BasePlugin)this).Config.Bind<float>("Stamina Regain", "Regain Speed", 20f, "How fast stamina regains.");
staminaJumpDrain = ((BasePlugin)this).Config.Bind<float>("Stamina Jump Drain", "Jump Drain Amount", -15f, "How much stamina drained by jumping.");
minStamToRunJump = ((BasePlugin)this).Config.Bind<float>("Allowed Run/Jump At", "Minimum", 35f, "Minimum amount of stamina before allowing player to run/jump again.");
minStamToAttack = ((BasePlugin)this).Config.Bind<float>("Allowed Attack At", "Minimum", 1f, "Minimum amount of stamina before allowing player to attack.");
staminaBar = ((BasePlugin)this).Config.Bind<bool>("Stamina Bar", "Enabled", true, "Show's a visible stamina bar at the bottom of the screen.");
try
{
harmony = new Harmony("StaminaSystem");
harmony.PatchAll();
Logger.LogInfo((object)"All patches applied.");
}
catch (Exception ex)
{
ManualLogSource logger = Logger;
bool flag = default(bool);
BepInExErrorLogInterpolatedStringHandler val = new BepInExErrorLogInterpolatedStringHandler(19, 1, ref flag);
if (flag)
{
((BepInExLogInterpolatedStringHandler)val).AppendLiteral("Error during Load: ");
((BepInExLogInterpolatedStringHandler)val).AppendFormatted<Exception>(ex);
}
logger.LogError(val);
}
}
}
[HarmonyPatch(typeof(SessionData))]
[HarmonyPatch("PauseGame")]
public class PauseManager
{
public static void Prefix(ref bool showPauseText, ref bool delayOverride, ref bool openDesktopMode)
{
StaminaBar.isGamePaused = true;
}
}
[HarmonyPatch(typeof(SessionData))]
[HarmonyPatch("ResumeGame")]
public class ResumeGameManager
{
public static void Prefix()
{
StaminaBar.isGamePaused = false;
}
}
[HarmonyPatch(typeof(Player), "Update")]
public class StaminaBar
{
public static bool staminaBarCreated;
private static bool startedRunningOverStam;
public static bool isGamePaused = false;
public static bool isGameLoaded = false;
public static bool isPlayerJumping;
public static Image staminaFill;
public static Color currentColor;
public static float maxStamina = 100f;
public static float currentStamina;
public static RectTransform staminaFillRect;
private static PlayerInfoProvider _playerInfo;
private static FirstPersonController _control;
public static PlayerInfoProvider playerInfo
{
get
{
if (_playerInfo == null)
{
_playerInfo = new PlayerInfoProvider();
}
return _playerInfo;
}
}
public static FirstPersonController control
{
get
{
if ((Object)(object)_control == (Object)null)
{
_control = Object.FindObjectOfType<FirstPersonController>();
}
return _control;
}
}
[HarmonyPrefix]
public static void Prefix(Player __instance)
{
//IL_0043: Unknown result type (might be due to invalid IL or missing references)
//IL_0146: Unknown result type (might be due to invalid IL or missing references)
//IL_01ca: Unknown result type (might be due to invalid IL or missing references)
//IL_026e: Unknown result type (might be due to invalid IL or missing references)
//IL_0228: Unknown result type (might be due to invalid IL or missing references)
//IL_02c1: Unknown result type (might be due to invalid IL or missing references)
if (!staminaBarCreated)
{
currentStamina = maxStamina;
CreateStaminaBar.CreateBar();
staminaBarCreated = true;
}
if (!StaminaSystem.staminaBar.Value && staminaBarCreated)
{
((Graphic)staminaFill).color = CustomColors.Transparent;
}
if (playerInfo.GetIsRunning() && !isGamePaused)
{
if (currentStamina > StaminaSystem.minStamToRunJump.Value)
{
startedRunningOverStam = true;
}
CreateStaminaBar.UpdateStamina(StaminaSystem.staminaDrain.Value * Time.deltaTime);
}
else if (!playerInfo.GetIsRunning() && !isGamePaused && isGameLoaded)
{
CreateStaminaBar.UpdateStamina(StaminaSystem.staminaRegain.Value * Time.deltaTime);
startedRunningOverStam = false;
}
if (currentStamina <= 0f && !isGamePaused && isGameLoaded)
{
StatusController.Instance.disabledSprint = true;
StatusController.Instance.disabledJump = true;
control.m_Jump = false;
if (staminaBarCreated && StaminaSystem.staminaBar.Value)
{
((Graphic)staminaFill).color = CustomColors.Red;
}
}
else if (currentStamina < StaminaSystem.minStamToRunJump.Value && !startedRunningOverStam && !isGamePaused && isGameLoaded)
{
StatusController.Instance.disabledSprint = true;
StatusController.Instance.disabledJump = true;
control.m_Jump = false;
if (staminaBarCreated && StaminaSystem.staminaBar.Value)
{
((Graphic)staminaFill).color = CustomColors.Red;
}
}
else if (!isGamePaused && isGameLoaded)
{
StatusController.Instance.disabledSprint = false;
StatusController.Instance.disabledJump = false;
if (staminaBarCreated && StaminaSystem.staminaBar.Value)
{
((Graphic)staminaFill).color = CustomColors.Green;
}
}
if (isGamePaused && isGameLoaded && currentStamina != maxStamina && staminaBarCreated)
{
((Graphic)staminaFill).color = CustomColors.Transparent;
}
if (playerInfo.GetIsJumping())
{
CreateStaminaBar.UpdateStamina(StaminaSystem.staminaJumpDrain.Value);
control.m_Jumping = false;
}
if (__instance.playerKOInProgress)
{
CreateStaminaBar.ResetStamina();
((Graphic)staminaFill).color = CustomColors.Transparent;
}
if (currentStamina == maxStamina)
{
((Graphic)staminaFill).CrossFadeAlpha(0f, 0.2f, true);
}
else if (currentStamina != maxStamina)
{
((Graphic)staminaFill).CrossFadeAlpha(1f, 1f, true);
}
}
}
[HarmonyPatch(typeof(Player), "OnDestroy")]
public static class StaminaBarCleanup
{
[HarmonyPostfix]
public static void Postfix(Player __instance)
{
if (StaminaBar.staminaBarCreated)
{
CreateStaminaBar.DestroyBar();
StaminaBar.staminaBarCreated = false;
}
}
}
[HarmonyPatch(typeof(FirstPersonItemController), "MeleeAttack")]
[HarmonyPriority(600)]
public static class MeleeAttackPatch
{
public static void Prefix(FirstPersonItemController __instance)
{
//IL_002c: Unknown result type (might be due to invalid IL or missing references)
//IL_0032: Invalid comparison between Unknown and I4
if (StaminaBar.staminaBarCreated)
{
float value = StaminaSystem.staminaDrainMeleeWeapon.Value;
if (BioScreenController.Instance.selectedSlot != null && (int)BioScreenController.Instance.selectedSlot.isStatic == 3)
{
value = StaminaSystem.staminaDrainMeleeFist.Value;
}
CreateStaminaBar.UpdateStamina(value);
}
}
}
[HarmonyPatch(typeof(FirstPersonItemController), "OnInteraction")]
[HarmonyPriority(600)]
public static class OnInteractionPatch
{
public static bool hasBeenDelayed;
public static void Prefix(FirstPersonItemController __instance, InteractionKey input)
{
if (StaminaBar.currentStamina <= StaminaSystem.minStamToAttack.Value && !hasBeenDelayed)
{
float delayAmount = (StaminaSystem.minStamToRunJump.Value - StaminaBar.currentStamina + 0.7f) / 20f;
__instance.attackMainDelay += delayAmount;
hasBeenDelayed = true;
Task.Run(async delegate
{
await Task.Delay((int)(delayAmount * 1000f));
hasBeenDelayed = false;
});
}
}
}
[HarmonyPatch(typeof(FirstPersonItemController), "Block")]
[HarmonyPriority(600)]
public static class BlockPatch
{
public static void Prefix(FirstPersonItemController __instance)
{
if (StaminaBar.staminaBarCreated)
{
CreateStaminaBar.UpdateStamina(StaminaSystem.staminaDrainBlock.Value);
}
}
}
[HarmonyPatch(typeof(FirstPersonItemController), "ThrowGrenade")]
[HarmonyPriority(600)]
public static class ThrowGrenadePatch
{
public static void Prefix(FirstPersonItemController __instance)
{
if (StaminaBar.staminaBarCreated)
{
CreateStaminaBar.UpdateStamina(StaminaSystem.staminaDrainThrowables.Value);
}
}
}
}
