using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Pigeon.Movement;
using Sparroh.UI;
using TMPro;
using UnityEngine;
using UnityEngine.SceneManagement;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: AssemblyCompany("Coruscnium")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyDescription("Live DPS meter HUD overlay using SparrohUILib. Shows current 1s DPS, average DPS, and peak DPS.")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0.0")]
[assembly: AssemblyProduct("DPS Meter")]
[assembly: AssemblyTitle("DpsMeterMod")]
[assembly: AssemblyVersion("1.0.0.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
[CompilerGenerated]
[Embedded]
internal sealed class EmbeddedAttribute : Attribute
{
}
}
namespace System.Runtime.CompilerServices
{
[CompilerGenerated]
[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 DpsMeterMod
{
[BepInPlugin("coruscnium.dpsmeter", "DpsMeter", "1.0.2.0")]
[BepInProcess("Mycopunk.exe")]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[MycoMod(/*Could not decode attribute arguments.*/)]
public class Plugin : BaseUnityPlugin
{
public const string PluginGUID = "coruscnium.dpsmeter";
public const string PluginName = "DpsMeter";
public const string PluginVersion = "1.0.2.0";
internal static ManualLogSource Logger;
private static ConfigEntry<bool> _enabledConfig;
private static ConfigEntry<float> _anchorXConfig;
private static ConfigEntry<float> _anchorYConfig;
private static ConfigColor _dpsColorConfig;
private static ConfigColor _avgColorConfig;
private static ConfigColor _peakColorConfig;
private static ConfigColor _textColorConfig;
private HudHandle _hud;
private bool _hudBuilt;
private bool _loggedUpdateError;
private Harmony _harmony;
private FileSystemWatcher _configWatcher;
private volatile bool _reloadPending;
private float _reloadCooldown;
private const float ReloadDebounceSeconds = 0.25f;
private readonly Queue<(float time, float damage)> _damageWindow = new Queue<(float, float)>();
private float _peakDps;
private float _lastDamageTime;
private const float DpsWindowSeconds = 1f;
private const float AvgWindowSeconds = 15f;
private const float IdleResetSeconds = 3f;
private float _hudUpdateTimer;
private const float HudUpdateInterval = 0.25f;
internal static Plugin Instance { get; private set; }
private bool CanAttachHud => (Object)(object)Player.LocalPlayer != (Object)null && (Object)(object)Player.LocalPlayer.PlayerLook != (Object)null && (Object)(object)Player.LocalPlayer.PlayerLook.Reticle != (Object)null;
private bool IsHudAlive => _hud != null && (Object)(object)_hud.GameObject != (Object)null && _hud.Lines != null && _hud.Lines.Length != 0;
private void Awake()
{
//IL_008b: 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)
//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
//IL_0162: Unknown result type (might be due to invalid IL or missing references)
//IL_016c: Expected O, but got Unknown
Instance = this;
Logger = ((BaseUnityPlugin)this).Logger;
_enabledConfig = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "Enabled", true, "If true, the DPS meter HUD is visible.");
_anchorXConfig = ((BaseUnityPlugin)this).Config.Bind<float>("HUD Positioning", "AnchorX", 0.03123011f, "X anchor position for DPS meter (0-1).");
_anchorYConfig = ((BaseUnityPlugin)this).Config.Bind<float>("HUD Positioning", "AnchorY", 0.9360327f, "Y anchor position for DPS meter (0-1).");
_dpsColorConfig = ConfigColor.Bind(((BaseUnityPlugin)this).Config, "Colors", "DpsColor", UIColors.Rose, "Rich-text color for current DPS (hex RRGGBB or #RRGGBB).");
_avgColorConfig = ConfigColor.Bind(((BaseUnityPlugin)this).Config, "Colors", "AvgColor", UIColors.Sky, "Rich-text color for average DPS (hex RRGGBB or #RRGGBB).");
_peakColorConfig = ConfigColor.Bind(((BaseUnityPlugin)this).Config, "Colors", "PeakColor", UIColors.Macaroon, "Rich-text color for peak DPS (hex RRGGBB or #RRGGBB).");
_textColorConfig = ConfigColor.Bind(((BaseUnityPlugin)this).Config, "Colors", "TextColor", UIColors.TextPrimary, "Rich-text color for stat labels (hex RRGGBB or #RRGGBB).");
_enabledConfig.SettingChanged += delegate
{
UpdateHudVisibility();
};
_anchorXConfig.SettingChanged += delegate
{
UpdateAnchors();
};
_anchorYConfig.SettingChanged += delegate
{
UpdateAnchors();
};
((BaseUnityPlugin)this).Config.Save();
_harmony = new Harmony("coruscnium.dpsmeter");
ApplyPatches();
SetupConfigHotReload();
SceneManager.sceneLoaded += OnSceneLoaded;
_lastDamageTime = Time.unscaledTime;
Logger.LogInfo((object)"DpsMeter v1.0.2.0 loaded.");
}
private void ApplyPatches()
{
//IL_0077: Unknown result type (might be due to invalid IL or missing references)
//IL_0085: Expected O, but got Unknown
try
{
MethodInfo methodInfo = AccessTools.Method(typeof(PlayerData), "OnLocalPlayerDamageTarget", (Type[])null, (Type[])null);
if (methodInfo == null)
{
Logger.LogError((object)"PlayerData.OnLocalPlayerDamageTarget not found. Cannot track damage without this method.");
return;
}
MethodInfo method = typeof(Plugin).GetMethod("Pre_LocalPlayerDamageTarget", BindingFlags.Static | BindingFlags.NonPublic);
if (method == null)
{
Logger.LogError((object)"Patch method not found.");
return;
}
_harmony.Patch((MethodBase)methodInfo, new HarmonyMethod(method), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
Logger.LogInfo((object)"Harmony patch applied: PlayerData.OnLocalPlayerDamageTarget");
}
catch (Exception ex)
{
Logger.LogError((object)("Failed to apply Harmony patch: " + ex.Message));
}
}
private static void Pre_LocalPlayerDamageTarget(in DamageCallbackData data)
{
if (!((Object)(object)Instance == (Object)null))
{
float damage = data.damageData.damage;
if (!(damage <= 0f))
{
Instance.RecordDamage(damage, Time.unscaledTime);
}
}
}
internal void RecordDamage(float damage, float time)
{
_damageWindow.Enqueue((time, damage));
_lastDamageTime = time;
float num = time - 15f;
while (_damageWindow.Count > 0 && _damageWindow.Peek().time < num)
{
_damageWindow.Dequeue();
}
}
private float GetCurrentDps(float now)
{
if (now - _lastDamageTime > 3f)
{
return 0f;
}
return SumWindow(now, 1f) / 1f;
}
private float GetAverageDps(float now)
{
return SumWindow(now, 15f) / 15f;
}
private float SumWindow(float now, float windowSec)
{
if (_damageWindow.Count == 0)
{
return 0f;
}
float num = now - windowSec;
float num2 = 0f;
foreach (var item in _damageWindow)
{
if (item.time >= num)
{
num2 += item.damage;
}
}
return num2;
}
private void UpdatePeakDps(float currentDps)
{
if (currentDps > _peakDps)
{
_peakDps = currentDps;
}
}
private void SetupConfigHotReload()
{
try
{
string configFilePath = ((BaseUnityPlugin)this).Config.ConfigFilePath;
string directoryName = Path.GetDirectoryName(configFilePath);
string fileName = Path.GetFileName(configFilePath);
if (string.IsNullOrEmpty(directoryName) || string.IsNullOrEmpty(fileName))
{
Logger.LogWarning((object)"Could not set up config hot reload: invalid config path.");
return;
}
_configWatcher = new FileSystemWatcher(directoryName, fileName)
{
NotifyFilter = (NotifyFilters.FileName | NotifyFilters.Size | NotifyFilters.LastWrite),
EnableRaisingEvents = true
};
_configWatcher.Changed += OnConfigFileChanged;
_configWatcher.Created += OnConfigFileChanged;
_configWatcher.Renamed += OnConfigFileChanged;
Logger.LogInfo((object)("Config hot reload enabled for " + fileName));
}
catch (Exception ex)
{
Logger.LogWarning((object)("Failed to set up config hot reload: " + ex.Message));
}
}
private void OnConfigFileChanged(object sender, FileSystemEventArgs e)
{
_reloadPending = true;
}
private void CreateHud()
{
//IL_0064: Unknown result type (might be due to invalid IL or missing references)
if (IsHudAlive)
{
return;
}
ClearDestroyedHud();
_hudBuilt = false;
if (!CanAttachHud)
{
return;
}
_hud = HudBuilder.Create("DpsMeterHUD").ParentToReticle(true).Anchor(_anchorXConfig.Value, _anchorYConfig.Value)
.Pivot(new Vector2(0f, 1f))
.Size(280f, 80f, true)
.AddLines(3, UITheme.FontHud, (TextAlignmentOptions)513)
.Build();
if (!IsHudAlive)
{
Logger.LogWarning((object)"Failed to build DPS meter HUD.");
return;
}
for (int i = 1; i < _hud.Lines.Length; i++)
{
if (_hud.Lines[i] != null)
{
_hud.Lines[i].FontSize = UITheme.ScaledFontBody;
}
}
_hudBuilt = true;
try
{
HudRepositionAPI.Register("coruscnium.dpsmeter", "DpsMeterHUD", _hud.Rect, _anchorXConfig, _anchorYConfig);
}
catch (Exception ex)
{
Logger.LogWarning((object)("Failed to register HUD reposition client: " + ex.Message));
}
UpdateHudVisibility();
Logger.LogInfo((object)"DPS meter HUD created.");
}
private void ClearDestroyedHud()
{
if (_hud == null)
{
return;
}
try
{
HudRepositionAPI.Unregister("coruscnium.dpsmeter");
}
catch
{
}
try
{
if ((Object)(object)_hud.GameObject != (Object)null)
{
_hud.Destroy();
}
}
catch
{
}
_hud = null;
_hudBuilt = false;
}
private void UpdateHudVisibility()
{
if (!IsHudAlive)
{
ClearDestroyedHud();
}
else
{
_hud.SetActive(_enabledConfig.Value);
}
}
private void UpdateAnchors()
{
if (!IsHudAlive)
{
ClearDestroyedHud();
}
else
{
_hud.SetAnchor(_anchorXConfig.Value, _anchorYConfig.Value);
}
}
private void SetLine(int index, string text)
{
if (IsHudAlive && index >= 0 && index < _hud.Lines.Length)
{
UIText val = _hud.Lines[index];
if (val != null && !((Object)(object)val.Tmp == (Object)null))
{
val.Text = text ?? string.Empty;
}
}
}
private static string FmtDps(float value)
{
if (value >= 1000000f)
{
return $"{value / 1000000f:F1}M";
}
if (value >= 10000f)
{
return $"{value / 1000f:F1}K";
}
if (value >= 1000f)
{
return $"{value:F0}";
}
if (value >= 100f)
{
return $"{value:F0}";
}
return $"{value:F1}";
}
private void Update()
{
if (_reloadPending)
{
_reloadPending = false;
_reloadCooldown = 0.25f;
}
if (_reloadCooldown > 0f)
{
_reloadCooldown -= Time.unscaledDeltaTime;
if (_reloadCooldown <= 0f)
{
TryReloadConfig();
}
}
if (_enabledConfig == null || !_enabledConfig.Value)
{
if (IsHudAlive)
{
_hud.SetActive(false);
}
return;
}
if (!CanAttachHud)
{
if (_hudBuilt)
{
ClearDestroyedHud();
}
return;
}
if (!IsHudAlive)
{
CreateHud();
if (!IsHudAlive)
{
return;
}
}
if (!_hud.IsActive)
{
_hud.SetActive(true);
}
_hudUpdateTimer += Time.deltaTime;
if (!(_hudUpdateTimer >= 0.25f))
{
return;
}
_hudUpdateTimer = 0f;
try
{
RefreshHud();
}
catch (Exception ex)
{
if (!_loggedUpdateError)
{
_loggedUpdateError = true;
Logger.LogError((object)("Error updating DPS HUD: " + ex.Message));
}
}
}
private void RefreshHud()
{
//IL_004b: Unknown result type (might be due to invalid IL or missing references)
//IL_0044: Unknown result type (might be due to invalid IL or missing references)
//IL_0050: 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_005b: 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_0079: Unknown result type (might be due to invalid IL or missing references)
//IL_0072: 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_0088: Unknown result type (might be due to invalid IL or missing references)
//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
//IL_00be: Unknown result type (might be due to invalid IL or missing references)
float unscaledTime = Time.unscaledTime;
float currentDps = GetCurrentDps(unscaledTime);
float averageDps = GetAverageDps(unscaledTime);
UpdatePeakDps(currentDps);
string text = FmtDps(currentDps);
string text2 = FmtDps(averageDps);
string text3 = FmtDps(_peakDps);
ConfigColor dpsColorConfig = _dpsColorConfig;
Color val = ((dpsColorConfig != null) ? dpsColorConfig.Value : UIColors.Rose);
ConfigColor avgColorConfig = _avgColorConfig;
Color val2 = ((avgColorConfig != null) ? avgColorConfig.Value : UIColors.Sky);
ConfigColor peakColorConfig = _peakColorConfig;
Color val3 = ((peakColorConfig != null) ? peakColorConfig.Value : UIColors.Macaroon);
SetLine(0, RichText.Labeled("DPS", text, val, ""));
SetLine(1, RichText.Labeled("AVG", text2, val2, ""));
SetLine(2, RichText.Labeled("PEAK", text3, val3, ""));
}
private void TryReloadConfig()
{
try
{
((BaseUnityPlugin)this).Config.Reload();
Logger.LogInfo((object)"Config reloaded from disk.");
}
catch (IOException)
{
_reloadPending = true;
}
catch (Exception ex2)
{
Logger.LogWarning((object)("Failed to reload config: " + ex2.Message));
}
}
private void OnSceneLoaded(Scene scene, LoadSceneMode mode)
{
_damageWindow.Clear();
_peakDps = 0f;
_lastDamageTime = Time.unscaledTime;
_loggedUpdateError = false;
ClearDestroyedHud();
Logger.LogInfo((object)("Tracking reset on scene: " + ((Scene)(ref scene)).name));
}
private void OnDestroy()
{
if (_configWatcher != null)
{
_configWatcher.EnableRaisingEvents = false;
_configWatcher.Changed -= OnConfigFileChanged;
_configWatcher.Created -= OnConfigFileChanged;
_configWatcher.Renamed -= OnConfigFileChanged;
_configWatcher.Dispose();
_configWatcher = null;
}
try
{
if (_hud != null)
{
HudRepositionAPI.Unregister("coruscnium.dpsmeter");
if ((Object)(object)_hud.GameObject != (Object)null)
{
_hud.Destroy();
}
_hud = null;
}
}
catch (Exception ex)
{
Logger.LogError((object)("Error cleaning up HUD: " + ex.Message));
}
try
{
Harmony harmony = _harmony;
if (harmony != null)
{
harmony.UnpatchSelf();
}
}
catch (Exception ex2)
{
Logger.LogError((object)("Error unpatching Harmony: " + ex2.Message));
}
}
}
}
