using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
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 TMPro;
using UnityEngine;
using UnityEngine.UI;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: IgnoresAccessChecksTo("Assembly-CSharp")]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("com.StaminaStats")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.1.5.0")]
[assembly: AssemblyInformationalVersion("1.1.5")]
[assembly: AssemblyProduct("com.StaminaStats")]
[assembly: AssemblyTitle("StaminaStats")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.1.5.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.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;
}
}
[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 BepInEx
{
[AttributeUsage(AttributeTargets.Class, Inherited = false, AllowMultiple = false)]
[Conditional("CodeGeneration")]
internal sealed class BepInAutoPluginAttribute : Attribute
{
public BepInAutoPluginAttribute(string? id = null, string? name = null, string? version = null)
{
}
}
}
namespace BepInEx.Preloader.Core.Patching
{
[AttributeUsage(AttributeTargets.Class, Inherited = false, AllowMultiple = false)]
[Conditional("CodeGeneration")]
internal sealed class PatcherAutoPluginAttribute : Attribute
{
public PatcherAutoPluginAttribute(string? id = null, string? name = null, string? version = null)
{
}
}
}
namespace StaminaStats
{
[BepInPlugin("com.StaminaStats", "StaminaStats", "1.1.5")]
public class Plugin : BaseUnityPlugin
{
[HarmonyPatch(typeof(StaminaBar), "Update")]
private class StaminaBarPatch
{
private static void Postfix(StaminaBar __instance)
{
try
{
if (!((Object)(object)Character.observedCharacter == (Object)null))
{
if (!_elementsCreated || (Object)(object)_staminaTextContainer == (Object)null)
{
CreateStaminaTextElements(__instance);
_elementsCreated = true;
}
UpdateStaminaText(__instance);
}
}
catch (Exception ex)
{
Log.LogError((object)("Error in StaminaBar patch: " + ex.Message));
}
}
}
[HarmonyPatch(typeof(StaminaBar), "Start")]
private class StaminaBarStartPatch
{
private static void Postfix(StaminaBar __instance)
{
try
{
if (_verboseLogging.Value)
{
Log.LogInfo((object)"StaminaBar Start detected - ensuring UI is reset");
}
if (__instance.afflictions != null && __instance.afflictions.Length != 0 && _afflictionTexts.Count > 0)
{
ResetAfflictionUI();
}
}
catch (Exception ex)
{
Log.LogError((object)("Error in StaminaBar Start patch: " + ex.Message));
}
}
}
[HarmonyPatch(typeof(BarAffliction), "UpdateAffliction")]
private class BarAfflictionPatch
{
private static void Postfix(BarAffliction __instance, StaminaBar bar)
{
try
{
if (!((Object)(object)Character.observedCharacter == (Object)null))
{
UpdateAfflictionText(__instance, bar);
}
}
catch (Exception ex)
{
Log.LogError((object)("Error in BarAffliction patch: " + ex.Message));
}
}
}
[HarmonyPatch(typeof(StaminaBar), "ChangeBar")]
private class StaminaBarChangeBarPatch
{
private static void Postfix(StaminaBar __instance)
{
//IL_004d: Unknown result type (might be due to invalid IL or missing references)
//IL_0052: Unknown result type (might be due to invalid IL or missing references)
//IL_0062: Unknown result type (might be due to invalid IL or missing references)
//IL_008b: Unknown result type (might be due to invalid IL or missing references)
//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
//IL_00f3: 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_011b: Unknown result type (might be due to invalid IL or missing references)
//IL_0125: Unknown result type (might be due to invalid IL or missing references)
try
{
if ((Object)(object)Character.observedCharacter == (Object)null)
{
return;
}
if (_verboseLogging.Value)
{
Log.LogInfo((object)"StaminaBar ChangeBar called, enumerating afflictions:");
for (int i = 0; i < __instance.afflictions.Length; i++)
{
BarAffliction val = __instance.afflictions[i];
bool activeSelf = ((Component)val).gameObject.activeSelf;
STATUSTYPE afflictionType = val.afflictionType;
float num = Character.observedCharacter.refs.afflictions.GetCurrentStatus(afflictionType) * 100f;
Log.LogInfo((object)$" - Affliction {i}: {afflictionType}, Active: {activeSelf}, Value: {num:F0}%, Width: {val.width}");
}
}
foreach (STATUSTYPE value in Enum.GetValues(typeof(STATUSTYPE)))
{
float currentStatus = Character.observedCharacter.refs.afflictions.GetCurrentStatus(value);
if (currentStatus > 0f && !_afflictionTexts.ContainsKey(value))
{
BarAffliction val3 = FindAffliction(__instance, value);
if ((Object)(object)val3 != (Object)null)
{
UpdateAfflictionText(val3, __instance);
}
}
}
}
catch (Exception ex)
{
Log.LogError((object)("Error in StaminaBar ChangeBar patch: " + ex.Message));
}
}
}
public class AfflictionTextTracker : MonoBehaviour
{
private BarAffliction _affliction;
private RectTransform _textRect;
private float _verticalOffset;
private STATUSTYPE _statusType;
public void Initialize(BarAffliction affliction, float verticalOffset)
{
//IL_001c: Unknown result type (might be due to invalid IL or missing references)
//IL_0021: Unknown result type (might be due to invalid IL or missing references)
//IL_003d: Unknown result type (might be due to invalid IL or missing references)
_affliction = affliction;
_textRect = ((Component)this).GetComponent<RectTransform>();
_verticalOffset = verticalOffset;
_statusType = affliction.afflictionType;
if (_verboseLogging.Value)
{
Log.LogInfo((object)$"Initialized AfflictionTextTracker for {_statusType}");
}
}
public void UpdateWidth(float width)
{
//IL_001b: Unknown result type (might be due to invalid IL or missing references)
//IL_0025: Unknown result type (might be due to invalid IL or missing references)
if ((Object)(object)_textRect != (Object)null)
{
_textRect.sizeDelta = new Vector2(width, _textRect.sizeDelta.y);
}
}
public void UpdateAffliction(BarAffliction newAffliction)
{
//IL_0035: Unknown result type (might be due to invalid IL or missing references)
if ((Object)(object)newAffliction != (Object)null && (Object)(object)_affliction != (Object)(object)newAffliction)
{
_affliction = newAffliction;
if (_verboseLogging.Value)
{
Log.LogInfo((object)$"Updated affliction reference for {_statusType}");
}
}
}
private void LateUpdate()
{
//IL_0042: Unknown result type (might be due to invalid IL or missing references)
//IL_0047: Unknown result type (might be due to invalid IL or missing references)
//IL_004e: Unknown result type (might be due to invalid IL or missing references)
//IL_0054: Unknown result type (might be due to invalid IL or missing references)
//IL_0067: Unknown result type (might be due to invalid IL or missing references)
//IL_0071: Unknown result type (might be due to invalid IL or missing references)
//IL_009e: Unknown result type (might be due to invalid IL or missing references)
if ((Object)(object)_affliction == (Object)null || (Object)(object)_textRect == (Object)null)
{
return;
}
Canvas componentInParent = ((Component)_affliction).GetComponentInParent<Canvas>();
if (!((Object)(object)componentInParent != (Object)null))
{
return;
}
RectTransform component = ((Component)_affliction).GetComponent<RectTransform>();
Vector3 position = ((Transform)component).position;
((Transform)_textRect).position = new Vector3(position.x, position.y + _verticalOffset, ((Transform)_textRect).position.z);
float num = 0f;
if ((Object)(object)Character.observedCharacter != (Object)null)
{
num = Character.observedCharacter.refs.afflictions.GetCurrentStatus(_statusType) * 100f;
}
TextMeshProUGUI val = default(TextMeshProUGUI);
if (num > 0f && ((Component)this).TryGetComponent<TextMeshProUGUI>(ref val))
{
string text = (_showPercentageSign.Value ? $"{num:F0}%" : $"{num:F0}");
if (((TMP_Text)val).text != text)
{
((TMP_Text)val).text = text;
}
}
bool flag = num > 0f;
if (((Component)this).gameObject.activeSelf != flag)
{
((Component)this).gameObject.SetActive(flag);
}
}
}
public const string PluginVersion = "1.1.5";
private static Harmony? _harmony;
private static bool _elementsCreated = false;
private static ConfigEntry<bool> _showPercentageSign;
private static ConfigEntry<int> _staminaFontSize;
private static ConfigEntry<int> _afflictionFontSize;
private static ConfigEntry<float> _outlineThickness;
private static ConfigEntry<bool> _verboseLogging;
private static GameObject? _staminaTextContainer;
private static TextMeshProUGUI? _staminaText;
private static TextMeshProUGUI? _extraStaminaText;
private static Dictionary<STATUSTYPE, TextMeshProUGUI> _afflictionTexts = new Dictionary<STATUSTYPE, TextMeshProUGUI>();
private static Canvas _afflictionCanvas;
private static TMP_FontAsset? _gameFont = null;
private static Material? _textMaterial = null;
private static readonly Color LowStaminaColor = new Color(1f, 0.3f, 0.3f);
private static readonly Color MediumStaminaColor = new Color(1f, 0.92f, 0.016f);
private static readonly Color HighStaminaColor = new Color(0.5f, 1f, 0.5f);
private static readonly Color ExtraStaminaColor = new Color(1f, 0.92f, 0.016f);
private static readonly Dictionary<STATUSTYPE, Color> StatusColors = new Dictionary<STATUSTYPE, Color>
{
{
(STATUSTYPE)0,
new Color(1f, 0.3f, 0.3f)
},
{
(STATUSTYPE)1,
new Color(0.9f, 0.6f, 0.1f)
},
{
(STATUSTYPE)2,
new Color(0.2f, 0.6f, 0.9f)
},
{
(STATUSTYPE)3,
new Color(0.6f, 0.1f, 0.6f)
},
{
(STATUSTYPE)4,
new Color(0.9f, 0.4f, 0.4f)
},
{
(STATUSTYPE)5,
new Color(0.5f, 0.1f, 0.5f)
},
{
(STATUSTYPE)6,
new Color(1f, 0.4f, 0.8f)
},
{
(STATUSTYPE)7,
new Color(0.6f, 0.4f, 0.2f)
},
{
(STATUSTYPE)8,
new Color(1f, 0.3f, 0.1f)
}
};
public const string Id = "com.StaminaStats";
internal static ManualLogSource Log { get; private set; } = null;
public static string Name => "StaminaStats";
public static string Version => "1.1.5";
private void Awake()
{
//IL_0021: Unknown result type (might be due to invalid IL or missing references)
//IL_002b: Expected O, but got Unknown
//IL_00de: Unknown result type (might be due to invalid IL or missing references)
//IL_00e8: Expected O, but got Unknown
//IL_0096: Unknown result type (might be due to invalid IL or missing references)
//IL_009b: Unknown result type (might be due to invalid IL or missing references)
//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
//IL_00b2: Expected I4, but got Unknown
Log = ((BaseUnityPlugin)this).Logger;
InitializeConfig();
_harmony = new Harmony(((BaseUnityPlugin)this).Info.Metadata.GUID);
_harmony.PatchAll();
Log.LogInfo((object)("Plugin " + ((BaseUnityPlugin)this).Info.Metadata.Name + " v1.1.5 loaded"));
if (_verboseLogging.Value)
{
Log.LogInfo((object)"Available STATUSTYPE enum values:");
foreach (STATUSTYPE value in Enum.GetValues(typeof(STATUSTYPE)))
{
Log.LogInfo((object)$" - {(object)value} (Value: {(int)value})");
}
}
Application.logMessageReceived += new LogCallback(OnLogMessageReceived);
}
private void OnDestroy()
{
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
//IL_0011: Expected O, but got Unknown
Application.logMessageReceived -= new LogCallback(OnLogMessageReceived);
CleanupUIElements();
}
private void OnLogMessageReceived(string logString, string stackTrace, LogType logType)
{
if (logString.Contains("RUN STARTED"))
{
if (_verboseLogging.Value)
{
Log.LogInfo((object)"Detected new run starting! Resetting affliction UI elements...");
}
ResetAfflictionUI();
}
}
private static void ResetAfflictionUI()
{
try
{
CleanupAfflictionTexts();
_elementsCreated = false;
if (_verboseLogging.Value)
{
Log.LogInfo((object)"Affliction UI elements reset successfully");
}
}
catch (Exception ex)
{
Log.LogError((object)("Error resetting affliction UI: " + ex.Message));
}
}
private static void CleanupAfflictionTexts()
{
try
{
if (_afflictionTexts.Count <= 0)
{
return;
}
if (_verboseLogging.Value)
{
Log.LogInfo((object)$"Cleaning up {_afflictionTexts.Count} affliction text elements");
}
foreach (KeyValuePair<STATUSTYPE, TextMeshProUGUI> item in _afflictionTexts.ToList())
{
if ((Object)(object)item.Value != (Object)null && (Object)(object)((Component)item.Value).gameObject != (Object)null)
{
Object.Destroy((Object)(object)((Component)item.Value).gameObject);
}
}
_afflictionTexts.Clear();
}
catch (Exception ex)
{
Log.LogError((object)("Error cleaning up affliction texts: " + ex.Message));
}
}
private static void CleanupUIElements()
{
try
{
CleanupAfflictionTexts();
if ((Object)(object)_staminaTextContainer != (Object)null)
{
Object.Destroy((Object)(object)_staminaTextContainer);
_staminaTextContainer = null;
_staminaText = null;
_extraStaminaText = null;
}
if ((Object)(object)_afflictionCanvas != (Object)null)
{
Object.Destroy((Object)(object)((Component)_afflictionCanvas).gameObject);
_afflictionCanvas = null;
}
_elementsCreated = false;
if (_verboseLogging.Value)
{
Log.LogInfo((object)"All UI elements cleaned up");
}
}
catch (Exception ex)
{
Log.LogError((object)("Error cleaning up UI elements: " + ex.Message));
}
}
private void InitializeConfig()
{
//IL_0045: Unknown result type (might be due to invalid IL or missing references)
//IL_004f: Expected O, but got Unknown
//IL_0079: Unknown result type (might be due to invalid IL or missing references)
//IL_0083: Expected O, but got Unknown
//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
//IL_00c0: Expected O, but got Unknown
_showPercentageSign = ((BaseUnityPlugin)this).Config.Bind<bool>("Display", "ShowPercentageSign", false, "Whether to show a percentage sign (%) after numeric values.");
_staminaFontSize = ((BaseUnityPlugin)this).Config.Bind<int>("Display", "StaminaFontSize", 18, new ConfigDescription("Font size for stamina text display.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(10, 32), Array.Empty<object>()));
_afflictionFontSize = ((BaseUnityPlugin)this).Config.Bind<int>("Display", "AfflictionFontSize", 16, new ConfigDescription("Font size for affliction text display.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(10, 32), Array.Empty<object>()));
_outlineThickness = ((BaseUnityPlugin)this).Config.Bind<float>("Display", "TextOutlineThickness", 0.1f, new ConfigDescription("Thickness of the text outline for better readability. Higher values make text more readable against busy backgrounds.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.1f, 0.3f), Array.Empty<object>()));
_verboseLogging = ((BaseUnityPlugin)this).Config.Bind<bool>("Debug", "VerboseLogging", false, "Enable detailed logging for debugging purposes.");
if (_verboseLogging.Value)
{
Log.LogInfo((object)"Configuration loaded:");
Log.LogInfo((object)$" - Show percentage sign: {_showPercentageSign.Value}");
Log.LogInfo((object)$" - Stamina font size: {_staminaFontSize.Value}");
Log.LogInfo((object)$" - Affliction font size: {_afflictionFontSize.Value}");
Log.LogInfo((object)$" - Text outline thickness: {_outlineThickness.Value}");
}
}
private static BarAffliction FindAffliction(StaminaBar staminaBar, STATUSTYPE type)
{
//IL_0010: 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)
BarAffliction[] afflictions = staminaBar.afflictions;
foreach (BarAffliction val in afflictions)
{
if (val.afflictionType == type)
{
return val;
}
}
return null;
}
private static void EnsureAfflictionCanvas()
{
//IL_0015: Unknown result type (might be due to invalid IL or missing references)
//IL_001b: Expected O, but got Unknown
//IL_005c: Unknown result type (might be due to invalid IL or missing references)
if ((Object)(object)_afflictionCanvas == (Object)null)
{
GameObject val = new GameObject("AfflictionTextCanvas");
Object.DontDestroyOnLoad((Object)(object)val);
_afflictionCanvas = val.AddComponent<Canvas>();
_afflictionCanvas.renderMode = (RenderMode)0;
_afflictionCanvas.sortingOrder = 100;
CanvasScaler val2 = val.AddComponent<CanvasScaler>();
val2.uiScaleMode = (ScaleMode)1;
val2.referenceResolution = new Vector2(1920f, 1080f);
val2.screenMatchMode = (ScreenMatchMode)1;
GraphicRaycaster val3 = val.AddComponent<GraphicRaycaster>();
val.layer = LayerMask.NameToLayer("UI");
if (_verboseLogging.Value)
{
Log.LogInfo((object)"Created top-level affliction canvas");
}
}
}
private static void UpdateAfflictionText(BarAffliction affliction, StaminaBar bar)
{
//IL_0309: Unknown result type (might be due to invalid IL or missing references)
//IL_0025: Unknown result type (might be due to invalid IL or missing references)
//IL_002a: Unknown result type (might be due to invalid IL or missing references)
//IL_003a: Unknown result type (might be due to invalid IL or missing references)
//IL_0013: Unknown result type (might be due to invalid IL or missing references)
//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
//IL_0065: Unknown result type (might be due to invalid IL or missing references)
//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
//IL_00eb: Expected O, but got Unknown
//IL_011f: Unknown result type (might be due to invalid IL or missing references)
//IL_0135: Unknown result type (might be due to invalid IL or missing references)
//IL_014b: Unknown result type (might be due to invalid IL or missing references)
//IL_0176: Unknown result type (might be due to invalid IL or missing references)
//IL_01b3: Unknown result type (might be due to invalid IL or missing references)
//IL_01d0: Unknown result type (might be due to invalid IL or missing references)
//IL_0275: Unknown result type (might be due to invalid IL or missing references)
//IL_0280: Unknown result type (might be due to invalid IL or missing references)
//IL_0297: Unknown result type (might be due to invalid IL or missing references)
//IL_029c: Unknown result type (might be due to invalid IL or missing references)
//IL_029e: Unknown result type (might be due to invalid IL or missing references)
//IL_02c8: Unknown result type (might be due to invalid IL or missing references)
try
{
if (!((Component)affliction).gameObject.activeSelf && !_afflictionTexts.ContainsKey(affliction.afflictionType))
{
return;
}
STATUSTYPE afflictionType = affliction.afflictionType;
float num = Character.observedCharacter.refs.afflictions.GetCurrentStatus(afflictionType) * 100f;
if (_verboseLogging.Value)
{
Log.LogInfo((object)$"Processing affliction: {afflictionType}, active={((Component)affliction).gameObject.activeSelf}, width={affliction.width}, value={num:F0}%");
}
TextMeshProUGUI value = null;
if (!_afflictionTexts.TryGetValue(afflictionType, out value) || (Object)(object)value == (Object)null)
{
if ((Object)(object)_gameFont == (Object)null)
{
FindGameTextStyle();
}
EnsureAfflictionCanvas();
GameObject val = new GameObject($"{afflictionType}Text");
val.transform.SetParent(((Component)_afflictionCanvas).transform, false);
value = val.AddComponent<TextMeshProUGUI>();
RectTransform component = val.GetComponent<RectTransform>();
component.anchorMin = new Vector2(0.5f, 0.5f);
component.anchorMax = new Vector2(0.5f, 0.5f);
component.pivot = new Vector2(0.5f, 0.5f);
float num2 = Mathf.Max(40f, affliction.width * 0.8f);
component.sizeDelta = new Vector2(num2, 24f);
val.AddComponent<AfflictionTextTracker>().Initialize(affliction, -15f);
SetupGameTextStyle(value, _afflictionFontSize.Value, (TextAlignmentOptions)514);
((Graphic)value).raycastTarget = false;
_afflictionTexts[afflictionType] = value;
if (_verboseLogging.Value)
{
Log.LogInfo((object)$"Created new text component for {afflictionType}");
}
}
else
{
((TMP_Text)value).fontSize = _afflictionFontSize.Value;
((TMP_Text)value).outlineWidth = _outlineThickness.Value;
AfflictionTextTracker component2 = ((Component)value).GetComponent<AfflictionTextTracker>();
if ((Object)(object)component2 != (Object)null)
{
component2.UpdateWidth(Mathf.Max(40f, affliction.width * 0.8f));
component2.UpdateAffliction(affliction);
}
}
string text = (_showPercentageSign.Value ? $"{num:F0}%" : $"{num:F0}");
((TMP_Text)value).text = text;
if (StatusColors.TryGetValue(afflictionType, out var value2))
{
((Graphic)value).color = value2;
}
else
{
Image componentInChildren = ((Component)affliction).GetComponentInChildren<Image>();
if (componentInChildren != null)
{
Color color = ((Graphic)componentInChildren).color;
float num3 = default(float);
float num4 = default(float);
float num5 = default(float);
Color.RGBToHSV(color, ref num3, ref num4, ref num5);
((Graphic)value).color = Color.HSVToRGB(num3, Mathf.Clamp01(num4 * 1.2f), Mathf.Clamp01(num5 * 1.3f));
}
}
if (((Component)value).gameObject.activeSelf != num > 0f)
{
((Component)value).gameObject.SetActive(num > 0f);
}
}
catch (Exception ex)
{
Log.LogError((object)$"Error updating affliction text for {affliction.afflictionType}: {ex.Message}");
if (_verboseLogging.Value)
{
Log.LogError((object)("Stack trace: " + ex.StackTrace));
}
}
}
private static void CreateStaminaTextElements(StaminaBar staminaBar)
{
//IL_0040: Unknown result type (might be due to invalid IL or missing references)
//IL_004a: Expected O, but got Unknown
//IL_0065: Unknown result type (might be due to invalid IL or missing references)
//IL_006b: Expected O, but got Unknown
//IL_009e: Unknown result type (might be due to invalid IL or missing references)
//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
//IL_011a: Unknown result type (might be due to invalid IL or missing references)
//IL_0120: Expected O, but got Unknown
//IL_0153: Unknown result type (might be due to invalid IL or missing references)
//IL_0168: Unknown result type (might be due to invalid IL or missing references)
//IL_017d: Unknown result type (might be due to invalid IL or missing references)
//IL_0192: Unknown result type (might be due to invalid IL or missing references)
//IL_01a7: Unknown result type (might be due to invalid IL or missing references)
//IL_01cf: Unknown result type (might be due to invalid IL or missing references)
try
{
if ((Object)(object)_staminaTextContainer != (Object)null)
{
Object.Destroy((Object)(object)_staminaTextContainer);
_staminaTextContainer = null;
_staminaText = null;
_extraStaminaText = null;
}
if ((Object)(object)_gameFont == (Object)null)
{
FindGameTextStyle();
}
_staminaTextContainer = new GameObject("StaminaTextContainer");
_staminaTextContainer.transform.SetParent(((Component)staminaBar).transform, false);
GameObject val = new GameObject("StaminaText");
val.transform.SetParent(_staminaTextContainer.transform, false);
_staminaText = val.AddComponent<TextMeshProUGUI>();
RectTransform component = val.GetComponent<RectTransform>();
component.anchorMin = new Vector2(0.5f, 0.5f);
component.anchorMax = new Vector2(0.5f, 0.5f);
component.pivot = new Vector2(1f, 0f);
component.sizeDelta = new Vector2(60f, 30f);
component.anchoredPosition = new Vector2(20f, 25f);
SetupGameTextStyle(_staminaText, _staminaFontSize.Value, (TextAlignmentOptions)516);
GameObject val2 = new GameObject("ExtraStaminaText");
val2.transform.SetParent(_staminaTextContainer.transform, false);
_extraStaminaText = val2.AddComponent<TextMeshProUGUI>();
RectTransform component2 = val2.GetComponent<RectTransform>();
component2.anchorMin = new Vector2(0.5f, 0.5f);
component2.anchorMax = new Vector2(0.5f, 0.5f);
component2.pivot = new Vector2(0f, 0f);
component2.sizeDelta = new Vector2(60f, 30f);
component2.anchoredPosition = new Vector2(24f, 25f);
SetupGameTextStyle(_extraStaminaText, _staminaFontSize.Value, (TextAlignmentOptions)513);
((Graphic)_extraStaminaText).color = ExtraStaminaColor;
if (_verboseLogging.Value)
{
Log.LogInfo((object)"Created stamina text elements");
}
}
catch (Exception ex)
{
Log.LogError((object)("Error creating stamina text: " + ex.Message));
_elementsCreated = false;
}
}
private static void FindGameTextStyle()
{
try
{
TextMeshProUGUI[] array = Resources.FindObjectsOfTypeAll<TextMeshProUGUI>();
TextMeshProUGUI[] array2 = array;
foreach (TextMeshProUGUI val in array2)
{
if (((Object)val).name == "InteractNameText" || ((Object)val).name == "InteractPromptText" || ((Object)val).name == "ItemPromptMain")
{
_gameFont = ((TMP_Text)val).font;
_textMaterial = ((Graphic)val).material;
if (_verboseLogging.Value)
{
Log.LogInfo((object)("Found game font: " + ((Object)_gameFont).name));
}
return;
}
}
TMP_FontAsset[] array3 = Resources.FindObjectsOfTypeAll<TMP_FontAsset>();
int num = 0;
if (num < array3.Length)
{
TMP_FontAsset gameFont = array3[num];
_gameFont = gameFont;
if (_verboseLogging.Value)
{
Log.LogInfo((object)("Using fallback game font: " + ((Object)_gameFont).name));
}
}
}
catch (Exception ex)
{
Log.LogError((object)("Error finding game text style: " + ex.Message));
}
}
private static void SetupGameTextStyle(TextMeshProUGUI text, int fontSize, TextAlignmentOptions alignment)
{
//IL_0009: Unknown result type (might be due to invalid IL or missing references)
//IL_001e: Unknown result type (might be due to invalid IL or missing references)
//IL_0079: Unknown result type (might be due to invalid IL or missing references)
//IL_008e: 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_00c2: Unknown result type (might be due to invalid IL or missing references)
//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
((TMP_Text)text).fontSize = fontSize;
((TMP_Text)text).alignment = alignment;
((TMP_Text)text).textWrappingMode = (TextWrappingModes)0;
((TMP_Text)text).overflowMode = (TextOverflowModes)0;
((Graphic)text).color = Color.white;
if ((Object)(object)_gameFont != (Object)null)
{
((TMP_Text)text).font = _gameFont;
}
if ((Object)(object)_textMaterial != (Object)null)
{
((Graphic)text).material = _textMaterial;
}
Shadow val = ((Component)text).gameObject.AddComponent<Shadow>();
val.effectColor = new Color(0f, 0f, 0f, 0.95f);
val.effectDistance = new Vector2(2f, -2f);
((TMP_Text)text).outlineWidth = _outlineThickness.Value;
((TMP_Text)text).outlineColor = Color32.op_Implicit(new Color(0f, 0f, 0f, 1f));
((TMP_Text)text).enableAutoSizing = false;
((TMP_Text)text).fontStyle = (FontStyles)1;
((TMP_Text)text).faceColor = new Color32(byte.MaxValue, byte.MaxValue, byte.MaxValue, byte.MaxValue);
Canvas.ForceUpdateCanvases();
}
private static void UpdateStaminaText(StaminaBar staminaBar)
{
try
{
if ((Object)(object)_staminaText == (Object)null || (Object)(object)Character.observedCharacter == (Object)null)
{
return;
}
float num = Character.observedCharacter.data.currentStamina * 100f;
float num2 = Character.observedCharacter.data.extraStamina * 100f;
((TMP_Text)_staminaText).fontSize = _staminaFontSize.Value;
((TMP_Text)_staminaText).outlineWidth = _outlineThickness.Value;
if ((Object)(object)_extraStaminaText != (Object)null)
{
((TMP_Text)_extraStaminaText).fontSize = _staminaFontSize.Value;
((TMP_Text)_extraStaminaText).outlineWidth = _outlineThickness.Value;
}
((TMP_Text)_staminaText).text = (_showPercentageSign.Value ? $"{num:F0}%" : $"{num:F0}");
if ((Object)(object)_extraStaminaText != (Object)null)
{
if (num2 > 0f)
{
((Component)_extraStaminaText).gameObject.SetActive(true);
((TMP_Text)_extraStaminaText).text = (_showPercentageSign.Value ? $" +{num2:F0}%" : $" +{num2:F0}");
}
else
{
((Component)_extraStaminaText).gameObject.SetActive(false);
}
}
UpdateStaminaTextColor(num, Character.observedCharacter.GetMaxStamina() * 100f, num2, staminaBar);
if ((Object)(object)_staminaTextContainer != (Object)null)
{
bool active = ((Component)staminaBar.staminaBar).gameObject.activeSelf && !Character.observedCharacter.data.fullyPassedOut && !Character.observedCharacter.data.dead;
_staminaTextContainer.SetActive(active);
}
}
catch (Exception ex)
{
Log.LogError((object)("Error updating stamina text: " + ex.Message));
}
}
private static void UpdateStaminaTextColor(float currentStamina, float maxStamina, float extraStamina, StaminaBar staminaBar)
{
//IL_0026: Unknown result type (might be due to invalid IL or missing references)
//IL_002b: Unknown result type (might be due to invalid IL or missing references)
//IL_002d: Unknown result type (might be due to invalid IL or missing references)
//IL_0056: Unknown result type (might be due to invalid IL or missing references)
//IL_005b: Unknown result type (might be due to invalid IL or missing references)
//IL_0066: Unknown result type (might be due to invalid IL or missing references)
//IL_006b: Unknown result type (might be due to invalid IL or missing references)
//IL_0084: Unknown result type (might be due to invalid IL or missing references)
//IL_009f: Unknown result type (might be due to invalid IL or missing references)
//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
//IL_007e: Unknown result type (might be due to invalid IL or missing references)
//IL_0083: Unknown result type (might be due to invalid IL or missing references)
//IL_0076: Unknown result type (might be due to invalid IL or missing references)
//IL_007b: Unknown result type (might be due to invalid IL or missing references)
//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
try
{
if (!((Object)(object)_staminaText == (Object)null))
{
float num = currentStamina / maxStamina;
Image component = ((Component)staminaBar.staminaBar).GetComponent<Image>();
Color val;
if (component == null)
{
val = ((num < 0.25f) ? LowStaminaColor : ((!(num < 0.5f)) ? HighStaminaColor : MediumStaminaColor));
}
else
{
Color color = ((Graphic)component).color;
float num2 = default(float);
float num3 = default(float);
float num4 = default(float);
Color.RGBToHSV(color, ref num2, ref num3, ref num4);
val = Color.HSVToRGB(num2, Mathf.Clamp01(num3 * 1.2f), Mathf.Clamp01(num4 * 1.3f));
}
float num5 = default(float);
float num6 = default(float);
float num7 = default(float);
Color.RGBToHSV(val, ref num5, ref num6, ref num7);
val = Color.HSVToRGB(num5, num6, Mathf.Max(0.8f, num7));
((Graphic)_staminaText).color = val;
if ((Object)(object)_extraStaminaText != (Object)null)
{
((Graphic)_extraStaminaText).color = ExtraStaminaColor;
}
}
}
catch (Exception ex)
{
Log.LogError((object)("Error updating text color: " + ex.Message));
}
}
}
}
namespace System.Runtime.CompilerServices
{
[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
internal sealed class IgnoresAccessChecksToAttribute : Attribute
{
public IgnoresAccessChecksToAttribute(string assemblyName)
{
}
}
}
