Decompiled source of JusticeForF7 v2026.1004.0

plugins/JusticeForF7/JusticeForF7.dll

Decompiled 2 months ago
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using JusticeForF7.Patches;
using Microsoft.CodeAnalysis;
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(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("JusticeForF7")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+e73e83160318795c0d6ed7ce4a54ffe6a7f0acd5")]
[assembly: AssemblyProduct("JusticeForF7")]
[assembly: AssemblyTitle("JusticeForF7")]
[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.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]
	[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]
	[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 JusticeForF7
{
	public interface IJusticeSettings
	{
		bool Enabled { get; }

		bool EnableLogging { get; }

		int RescanInterval { get; }

		bool HideNameplates { get; }

		bool HideDamageNumbers { get; }

		bool HideTargetRings { get; }

		bool HideXPOrbs { get; }

		bool HideCastBars { get; }

		bool HideOtherWorldText { get; }
	}
	public interface IModLogger
	{
		void LogInfo(string message);

		void LogDebug(string message);
	}
	internal interface IJusticeLifecycleEffects
	{
		void Start();

		void Stop();

		void Tick();

		void SceneLoaded();

		void ReportDisabled();
	}
	internal sealed class JusticeLifecycle
	{
		private readonly IJusticeLifecycleEffects _effects;

		private bool _running;

		private bool _disabledReported;

		public JusticeLifecycle(IJusticeLifecycleEffects effects)
		{
			_effects = effects;
		}

		public void Start(bool enabled)
		{
			if (!_running)
			{
				if (!enabled)
				{
					ReportDisabledOnce();
					return;
				}
				_disabledReported = false;
				_effects.Start();
				_running = true;
			}
		}

		public void Tick(bool enabled)
		{
			if (enabled)
			{
				Start(enabled: true);
			}
			else if (_running)
			{
				Stop();
				ReportDisabledOnce();
			}
			else
			{
				ReportDisabledOnce();
			}
			if (_running)
			{
				_effects.Tick();
			}
		}

		public void Stop()
		{
			if (!_running)
			{
				return;
			}
			try
			{
				_effects.Stop();
			}
			finally
			{
				_running = false;
			}
		}

		public void SceneLoaded()
		{
			if (_running)
			{
				_effects.SceneLoaded();
			}
		}

		private void ReportDisabledOnce()
		{
			if (!_disabledReported)
			{
				_disabledReported = true;
				_effects.ReportDisabled();
			}
		}
	}
	internal sealed class JusticeRuntime : IJusticeLifecycleEffects
	{
		private readonly IModLogger _log;

		private readonly IJusticeSettings _settings;

		private readonly CanvasVisibilityObserver _canvasVisibility = new CanvasVisibilityObserver();

		private readonly JusticeLifecycle _lifecycle;

		private Harmony? _harmony;

		private WorldUIHider? _hider;

		public JusticeRuntime(IModLogger log, IJusticeSettings settings)
		{
			_log = log;
			_settings = settings;
			_lifecycle = new JusticeLifecycle(this);
		}

		public void Start()
		{
			_lifecycle.Start(_settings.Enabled);
		}

		public void Tick()
		{
			_lifecycle.Tick(_settings.Enabled);
		}

		public void Stop()
		{
			_lifecycle.Stop();
		}

		void IJusticeLifecycleEffects.Start()
		{
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Expected O, but got Unknown
			try
			{
				_hider = new WorldUIHider(_log, _settings);
				NamePlatePatch.Hider = _hider;
				NpcNamePlatePatch.Hider = _hider;
				DmgPopPatch.Hider = _hider;
				XPBubPatch.Hider = _hider;
				_harmony = new Harmony("wow-much.justice-for-f7");
				_harmony.PatchAll();
				SceneManager.sceneLoaded += OnSceneLoaded;
				if (_settings.EnableLogging)
				{
					_log.LogInfo("Justice for F7 v2026.1004.0 loaded");
				}
			}
			catch
			{
				((IJusticeLifecycleEffects)this).Stop();
				throw;
			}
		}

		void IJusticeLifecycleEffects.Stop()
		{
			SceneManager.sceneLoaded -= OnSceneLoaded;
			try
			{
				Harmony? harmony = _harmony;
				if (harmony != null)
				{
					harmony.UnpatchSelf();
				}
			}
			finally
			{
				_harmony = null;
				try
				{
					_hider?.OnUIShown();
				}
				finally
				{
					_hider = null;
					_canvasVisibility.Reset();
					NamePlatePatch.Hider = null;
					NpcNamePlatePatch.Hider = null;
					DmgPopPatch.Hider = null;
					XPBubPatch.Hider = null;
				}
			}
		}

		void IJusticeLifecycleEffects.Tick()
		{
			if (_hider != null)
			{
				_canvasVisibility.Tick(_hider);
			}
		}

		void IJusticeLifecycleEffects.SceneLoaded()
		{
			_canvasVisibility.Reset();
			_hider?.OnSceneLoaded();
		}

		void IJusticeLifecycleEffects.ReportDisabled()
		{
			_log.LogInfo("Justice for F7 v2026.1004.0 loaded (disabled via config)");
		}

		private void OnSceneLoaded(Scene scene, LoadSceneMode mode)
		{
			_lifecycle.SceneLoaded();
		}
	}
	internal static class PluginInfo
	{
		public const string GUID = "wow-much.justice-for-f7";

		public const string Name = "Justice for F7";

		public const string Version = "2026.1004.0";
	}
	internal enum CanvasVisibilityAction
	{
		None,
		Tick,
		Show,
		Hide
	}
	internal readonly struct CanvasVisibilityState
	{
		internal bool IsInitialized { get; }

		internal bool IsEnabled { get; }

		internal CanvasVisibilityState(bool enabled)
		{
			IsInitialized = true;
			IsEnabled = enabled;
		}
	}
	internal readonly struct CanvasVisibilityObservation
	{
		internal CanvasVisibilityState State { get; }

		internal CanvasVisibilityAction Action { get; }

		internal CanvasVisibilityObservation(CanvasVisibilityState state, CanvasVisibilityAction action)
		{
			State = state;
			Action = action;
		}
	}
	internal static class CanvasVisibilityPolicy
	{
		internal static CanvasVisibilityState Reset()
		{
			return default(CanvasVisibilityState);
		}

		internal static CanvasVisibilityObservation Observe(CanvasVisibilityState previous, bool enabled)
		{
			CanvasVisibilityState state = new CanvasVisibilityState(enabled);
			if (!previous.IsInitialized)
			{
				return new CanvasVisibilityObservation(state, CanvasVisibilityAction.None);
			}
			if (previous.IsEnabled == enabled)
			{
				return new CanvasVisibilityObservation(state, CanvasVisibilityAction.Tick);
			}
			return new CanvasVisibilityObservation(state, enabled ? CanvasVisibilityAction.Show : CanvasVisibilityAction.Hide);
		}
	}
	internal enum WorldElementKind
	{
		Nameplates,
		DamageNumbers,
		TargetRings,
		XPOrbs,
		CastBars,
		OtherWorldText
	}
	internal readonly struct RescanState
	{
		internal int FramesSinceLastScan { get; }

		internal RescanState(int framesSinceLastScan)
		{
			FramesSinceLastScan = framesSinceLastScan;
		}
	}
	internal readonly struct RescanDecision
	{
		internal RescanState State { get; }

		internal bool ShouldScan { get; }

		internal RescanDecision(RescanState state, bool shouldScan)
		{
			State = state;
			ShouldScan = shouldScan;
		}
	}
	internal static class VisibilityPolicy
	{
		internal static RescanState ResetRescan()
		{
			return default(RescanState);
		}

		internal static bool IsCategoryEnabled(IJusticeSettings settings, WorldElementKind kind)
		{
			if (1 == 0)
			{
			}
			bool result = kind switch
			{
				WorldElementKind.Nameplates => settings.HideNameplates, 
				WorldElementKind.DamageNumbers => settings.HideDamageNumbers, 
				WorldElementKind.TargetRings => settings.HideTargetRings, 
				WorldElementKind.XPOrbs => settings.HideXPOrbs, 
				WorldElementKind.CastBars => settings.HideCastBars, 
				WorldElementKind.OtherWorldText => settings.HideOtherWorldText, 
				_ => throw new ArgumentOutOfRangeException("kind", kind, "Unknown world element kind"), 
			};
			if (1 == 0)
			{
			}
			return result;
		}

		internal static bool ShouldSuppressTransient(bool hidden, IJusticeSettings settings, WorldElementKind kind)
		{
			return hidden && IsCategoryEnabled(settings, kind);
		}

		internal static RescanDecision AdvanceRescan(RescanState previous, bool hidden, int interval)
		{
			if (!hidden || interval <= 0)
			{
				return new RescanDecision(previous, shouldScan: false);
			}
			int num = previous.FramesSinceLastScan + 1;
			if (num < interval)
			{
				return new RescanDecision(new RescanState(num), shouldScan: false);
			}
			return new RescanDecision(new RescanState(0), shouldScan: true);
		}
	}
	internal sealed class WorldUIHider
	{
		private readonly IModLogger _log;

		private readonly IJusticeSettings _settings;

		private readonly HashSet<Renderer> _disabledRenderers = new HashSet<Renderer>();

		private readonly HashSet<GameObject> _disabledGameObjects = new HashSet<GameObject>();

		private RescanState _rescanState;

		public bool IsHidden { get; private set; }

		public bool SuppressDamageNumbers => VisibilityPolicy.ShouldSuppressTransient(IsHidden, _settings, WorldElementKind.DamageNumbers);

		public bool SuppressXPOrbs => VisibilityPolicy.ShouldSuppressTransient(IsHidden, _settings, WorldElementKind.XPOrbs);

		public WorldUIHider(IModLogger log, IJusticeSettings settings)
		{
			_log = log;
			_settings = settings;
		}

		public void OnUIHidden()
		{
			IsHidden = true;
			_rescanState = VisibilityPolicy.ResetRescan();
			ScanAndHide();
		}

		public void OnUIShown()
		{
			IsHidden = false;
			RestoreAll();
		}

		public void Tick()
		{
			RescanDecision rescanDecision = VisibilityPolicy.AdvanceRescan(_rescanState, IsHidden, _settings.RescanInterval);
			_rescanState = rescanDecision.State;
			if (rescanDecision.ShouldScan)
			{
				ScanAndHide();
			}
		}

		public void OnSceneLoaded()
		{
			_disabledRenderers.Clear();
			_disabledGameObjects.Clear();
			if (IsHidden)
			{
				_rescanState = VisibilityPolicy.ResetRescan();
				ScanAndHide();
			}
		}

		internal void EnforceTargetIndicatorHidden(NamePlate? plate)
		{
			if (IsHidden && VisibilityPolicy.IsCategoryEnabled(_settings, WorldElementKind.Nameplates) && !((Object)(object)plate == (Object)null))
			{
				HideGameObject(plate.TargetInd);
			}
		}

		internal void EnforceHealthBarHidden(NamePlate? plate)
		{
			if (IsHidden && VisibilityPolicy.IsCategoryEnabled(_settings, WorldElementKind.Nameplates) && !((Object)(object)plate == (Object)null))
			{
				HideGameObject(plate.Lifebar);
			}
		}

		private void ScanAndHide()
		{
			int num = 0;
			if (VisibilityPolicy.IsCategoryEnabled(_settings, WorldElementKind.Nameplates))
			{
				num += HideNameplates();
			}
			if (VisibilityPolicy.IsCategoryEnabled(_settings, WorldElementKind.DamageNumbers))
			{
				num += HideDamageNumbers();
			}
			if (VisibilityPolicy.IsCategoryEnabled(_settings, WorldElementKind.TargetRings))
			{
				num += HideTargetRings();
			}
			if (VisibilityPolicy.IsCategoryEnabled(_settings, WorldElementKind.XPOrbs))
			{
				num += HideXPOrbs();
			}
			if (VisibilityPolicy.IsCategoryEnabled(_settings, WorldElementKind.CastBars))
			{
				num += HideCastBars();
			}
			if (VisibilityPolicy.IsCategoryEnabled(_settings, WorldElementKind.OtherWorldText))
			{
				num += HideOtherWorldText();
			}
			if (_settings.EnableLogging)
			{
				_log.LogDebug($"Scan complete: {num} elements hidden");
			}
		}

		private int HideNameplates()
		{
			int num = 0;
			NamePlate[] array = Object.FindObjectsOfType<NamePlate>();
			foreach (NamePlate plate in array)
			{
				num += HideNameplateElements(plate);
			}
			return num;
		}

		private int HideNameplateElements(NamePlate plate)
		{
			if ((Object)(object)plate == (Object)null)
			{
				return 0;
			}
			int num = 0;
			Renderer component = ((Component)plate).GetComponent<Renderer>();
			if ((Object)(object)component != (Object)null && component.enabled)
			{
				component.enabled = false;
				_disabledRenderers.Add(component);
				num++;
			}
			num += HideGameObject(plate.Lifebar);
			return num + HideGameObject(plate.TargetInd);
		}

		private int HideGameObject(GameObject gameObject)
		{
			if ((Object)(object)gameObject == (Object)null || !gameObject.activeSelf)
			{
				return 0;
			}
			gameObject.SetActive(false);
			_disabledGameObjects.Add(gameObject);
			return 1;
		}

		private int HideDamageNumbers()
		{
			int num = 0;
			DmgPop[] array = Object.FindObjectsOfType<DmgPop>();
			foreach (DmgPop val in array)
			{
				Renderer val2 = (((Object)(object)val.Num != (Object)null) ? ((Component)val.Num).GetComponent<Renderer>() : null);
				if ((Object)(object)val2 != (Object)null && val2.enabled)
				{
					val2.enabled = false;
					_disabledRenderers.Add(val2);
					num++;
				}
			}
			return num;
		}

		private int HideTargetRings()
		{
			int num = 0;
			Character[] array = Object.FindObjectsOfType<Character>();
			foreach (Character val in array)
			{
				GameObject targetRing = val.TargetRing;
				if ((Object)(object)targetRing != (Object)null && targetRing.activeSelf)
				{
					targetRing.SetActive(false);
					_disabledGameObjects.Add(targetRing);
					num++;
				}
			}
			return num;
		}

		private int HideXPOrbs()
		{
			int num = 0;
			XPBub[] array = Object.FindObjectsOfType<XPBub>();
			foreach (XPBub val in array)
			{
				Renderer component = ((Component)val).GetComponent<Renderer>();
				if ((Object)(object)component != (Object)null && component.enabled)
				{
					component.enabled = false;
					_disabledRenderers.Add(component);
					num++;
				}
			}
			return num;
		}

		private int HideCastBars()
		{
			int num = 0;
			FlashUIColors[] array = Object.FindObjectsOfType<FlashUIColors>();
			foreach (FlashUIColors val in array)
			{
				if (!((Object)(object)val.CastBar == (Object)null))
				{
					Renderer component = ((Component)val.CastBar).GetComponent<Renderer>();
					if ((Object)(object)component != (Object)null && component.enabled)
					{
						component.enabled = false;
						_disabledRenderers.Add(component);
						num++;
					}
				}
			}
			return num;
		}

		private int HideOtherWorldText()
		{
			int num = 0;
			TextMeshPro[] array = Object.FindObjectsOfType<TextMeshPro>();
			foreach (TextMeshPro val in array)
			{
				if (!((Object)(object)((Component)val).GetComponent<NamePlate>() != (Object)null) && !((Object)(object)((Component)val).GetComponent<DmgPop>() != (Object)null) && !((Object)(object)((Component)val).GetComponentInParent<DmgPop>() != (Object)null))
				{
					Renderer component = ((Component)val).GetComponent<Renderer>();
					if ((Object)(object)component != (Object)null && component.enabled)
					{
						component.enabled = false;
						_disabledRenderers.Add(component);
						num++;
					}
				}
			}
			return num;
		}

		private void RestoreAll()
		{
			int num = 0;
			int num2 = 0;
			_disabledRenderers.RemoveWhere((Renderer r) => (Object)(object)r == (Object)null);
			_disabledGameObjects.RemoveWhere((GameObject go) => (Object)(object)go == (Object)null);
			foreach (Renderer disabledRenderer in _disabledRenderers)
			{
				disabledRenderer.enabled = true;
				num++;
			}
			foreach (GameObject disabledGameObject in _disabledGameObjects)
			{
				disabledGameObject.SetActive(true);
				num2++;
			}
			_disabledRenderers.Clear();
			_disabledGameObjects.Clear();
			if (_settings.EnableLogging)
			{
				_log.LogDebug($"Restored {num} renderers, {num2} game objects");
			}
		}
	}
	[BepInPlugin("wow-much.justice-for-f7", "Justice for F7", "2026.1004.0")]
	public sealed class Plugin : BaseUnityPlugin
	{
		private sealed class BepInExModLogger : IModLogger
		{
			private readonly ManualLogSource _logger;

			public BepInExModLogger(ManualLogSource logger)
			{
				_logger = logger;
			}

			public void LogInfo(string message)
			{
				_logger.LogInfo((object)message);
			}

			public void LogDebug(string message)
			{
				_logger.LogDebug((object)message);
			}
		}

		private sealed class BepInExJusticeSettings : IJusticeSettings
		{
			private readonly ConfigEntry<bool> _enabled;

			private readonly ConfigEntry<bool> _enableLogging;

			private readonly ConfigEntry<int> _rescanInterval;

			private readonly ConfigEntry<bool> _hideNameplates;

			private readonly ConfigEntry<bool> _hideDamageNumbers;

			private readonly ConfigEntry<bool> _hideTargetRings;

			private readonly ConfigEntry<bool> _hideXPOrbs;

			private readonly ConfigEntry<bool> _hideCastBars;

			private readonly ConfigEntry<bool> _hideOtherWorldText;

			public bool Enabled => _enabled.Value;

			public bool EnableLogging => _enableLogging.Value;

			public int RescanInterval => _rescanInterval.Value;

			public bool HideNameplates => _hideNameplates.Value;

			public bool HideDamageNumbers => _hideDamageNumbers.Value;

			public bool HideTargetRings => _hideTargetRings.Value;

			public bool HideXPOrbs => _hideXPOrbs.Value;

			public bool HideCastBars => _hideCastBars.Value;

			public bool HideOtherWorldText => _hideOtherWorldText.Value;

			public BepInExJusticeSettings(ConfigFile config)
			{
				_enabled = config.Bind<bool>("General", "Enabled", true, "Master switch. When false, F7 behaves as vanilla.");
				_enableLogging = config.Bind<bool>("General", "EnableLogging", true, "Enable debug logging. Set to false to silence all mod log output.");
				_rescanInterval = config.Bind<int>("General", "RescanInterval", 30, "Frames between re-scans while UI is hidden (0 = disable re-scan).");
				_hideNameplates = config.Bind<bool>("Elements", "HideNameplates", true, "Hide NPC, SimPlayer, and player nameplates.");
				_hideDamageNumbers = config.Bind<bool>("Elements", "HideDamageNumbers", true, "Hide floating damage and heal numbers.");
				_hideTargetRings = config.Bind<bool>("Elements", "HideTargetRings", true, "Hide the selection ring under targeted characters.");
				_hideXPOrbs = config.Bind<bool>("Elements", "HideXPOrbs", true, "Hide XP orb particles.");
				_hideCastBars = config.Bind<bool>("Elements", "HideCastBars", true, "Hide NPC and SimPlayer cast bars above nameplates.");
				_hideOtherWorldText = config.Bind<bool>("Elements", "HideOtherWorldText", true, "Hide remaining world-space text (loot prompts, etc.).");
			}
		}

		private JusticeRuntime? _runtime;

		private void Awake()
		{
			((Object)((Component)this).gameObject).hideFlags = (HideFlags)61;
			BepInExJusticeSettings settings = new BepInExJusticeSettings(((BaseUnityPlugin)this).Config);
			_runtime = new JusticeRuntime(new BepInExModLogger(((BaseUnityPlugin)this).Logger), settings);
			_runtime.Start();
		}

		private void Update()
		{
			_runtime?.Tick();
		}

		private void OnDestroy()
		{
			_runtime?.Stop();
			_runtime = null;
		}
	}
}
namespace JusticeForF7.Patches
{
	internal sealed class CanvasVisibilityObserver
	{
		private CanvasVisibilityState _state;

		public void Reset()
		{
			_state = CanvasVisibilityPolicy.Reset();
		}

		public void Tick(WorldUIHider hider)
		{
			Canvas mainCanvas = GameData.MainCanvas;
			if (!((Object)(object)mainCanvas == (Object)null))
			{
				CanvasVisibilityObservation canvasVisibilityObservation = CanvasVisibilityPolicy.Observe(_state, ((Behaviour)mainCanvas).enabled);
				_state = canvasVisibilityObservation.State;
				switch (canvasVisibilityObservation.Action)
				{
				case CanvasVisibilityAction.None:
					break;
				case CanvasVisibilityAction.Tick:
					hider.Tick();
					break;
				case CanvasVisibilityAction.Show:
					hider.OnUIShown();
					break;
				case CanvasVisibilityAction.Hide:
					hider.OnUIHidden();
					break;
				}
			}
		}
	}
	[HarmonyPatch(typeof(Misc))]
	internal static class DmgPopPatch
	{
		public static WorldUIHider? Hider { get; set; }

		[HarmonyPatch("GenPopup")]
		[HarmonyPrefix]
		public static bool GenPopupPrefix(int _dmg, bool _crit, DamageType _type, Transform _tar)
		{
			return Hider == null || !Hider.SuppressDamageNumbers;
		}

		[HarmonyPatch("GenPopupString")]
		[HarmonyPrefix]
		public static bool GenPopupStringPrefix(string _msg, Transform _tar)
		{
			return Hider == null || !Hider.SuppressDamageNumbers;
		}
	}
	[HarmonyPatch(typeof(NamePlate), "Update")]
	internal static class NamePlatePatch
	{
		public static WorldUIHider? Hider { get; set; }

		[HarmonyPostfix]
		public static void Postfix(NamePlate __instance)
		{
			Hider?.EnforceTargetIndicatorHidden(__instance);
		}
	}
	[HarmonyPatch(typeof(NPC), "HandleNameTag")]
	internal static class NpcNamePlatePatch
	{
		public static WorldUIHider? Hider { get; set; }

		[HarmonyPostfix]
		public static void Postfix(NamePlate? ___NamePlateObject)
		{
			Hider?.EnforceHealthBarHidden(___NamePlateObject);
		}
	}
	[HarmonyPatch(typeof(Misc), "GetXPBalls")]
	internal static class XPBubPatch
	{
		public static WorldUIHider? Hider { get; set; }

		[HarmonyPrefix]
		public static bool Prefix(int amt, Vector3 callPos, Transform _tar)
		{
			return Hider == null || !Hider.SuppressXPOrbs;
		}
	}
}