using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
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 Photon.Pun;
using UnityEngine;

[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: IgnoresAccessChecksTo("")]
[assembly: AssemblyCompany("zabu")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("zabumod")]
[assembly: AssemblyTitle("zabumod")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.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 REPOJP.LowHealthChallengeMod
{
	[BepInPlugin("REPOJP.LowHealthChallenge", "LowHealthChallenge", "1.0.0")]
	public sealed class LowHealthChallengePlugin : BaseUnityPlugin
	{
		[HarmonyPatch(typeof(PlayerAvatar), "ChatMessageSendRPC")]
		private static class PlayerAvatar_ChatMessageSendRPC_Patch
		{
			private static void Postfix(PlayerAvatar __instance, string _message, PhotonMessageInfo _info)
			{
				if (Object.op_Implicit((Object)(object)__instance) && __instance.isLocal)
				{
					ExecuteCommand(_message);
				}
			}
		}

		[HarmonyPatch(typeof(PlayerAvatar), "AddToStatsManagerRPC")]
		private static class PlayerAvatar_AddToStatsManagerRPC_Patch
		{
			private static void Postfix(PlayerAvatar __instance)
			{
				if (Object.op_Implicit((Object)(object)Instance) && Instance.enableMod.Value && OverrideActive && IsHost() && Object.op_Implicit((Object)(object)__instance))
				{
					ApplyFixedHealthToSinglePlayer(__instance);
				}
			}
		}

		[HarmonyPatch(typeof(ShopManager), "GetAllItemsFromStatsManager")]
		private static class ShopManager_GetAllItemsFromStatsManager_Patch
		{
			private static void Postfix(ShopManager __instance)
			{
				if (Object.op_Implicit((Object)(object)Instance) && Instance.enableMod.Value && Instance.blockHealthUpgradeInShop.Value && IsHost() && Object.op_Implicit((Object)(object)__instance))
				{
					__instance.potentialItemUpgrades.RemoveAll(IsHealthUpgradeItem);
				}
			}
		}

		[HarmonyPatch(typeof(StatsManager), "Start")]
		private static class StatsManager_Start_Patch
		{
			private static void Postfix()
			{
				if (Object.op_Implicit((Object)(object)Instance) && Instance.enableMod.Value)
				{
					Instance.NormalizeConfigAndApply("StatsManagerStart");
				}
			}
		}

		[HarmonyPatch(typeof(RunManager), "ChangeLevel")]
		private static class RunManager_ChangeLevel_Patch
		{
			private static void Postfix()
			{
				if (Object.op_Implicit((Object)(object)Instance) && Instance.enableMod.Value && IsHost())
				{
					((MonoBehaviour)Instance).StartCoroutine(Instance.DelayedReapplyAfterLevelChange());
				}
			}
		}

		[CompilerGenerated]
		private sealed class <DelayedReapplyAfterLevelChange>d__45 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public LowHealthChallengePlugin <>4__this;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <DelayedReapplyAfterLevelChange>d__45(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0026: Unknown result type (might be due to invalid IL or missing references)
				//IL_0030: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitForSeconds(1f);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					if (!<>4__this.enableMod.Value)
					{
						return false;
					}
					if (!OverrideActive)
					{
						return false;
					}
					if (!IsHost())
					{
						return false;
					}
					<>4__this.RefreshHealthUpgradeItemsDisabledState();
					ApplyFixedHealthToAllPlayers();
					if (<>4__this.destroyExistingHealthUpgradeItems.Value)
					{
						<>4__this.DestroySpawnedHealthUpgradeItems();
					}
					return false;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		[CompilerGenerated]
		private sealed class <DestroyHealthUpgradeLoop>d__35 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public LowHealthChallengePlugin <>4__this;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <DestroyHealthUpgradeLoop>d__35(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0029: Unknown result type (might be due to invalid IL or missing references)
				//IL_0033: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					break;
				case 1:
					<>1__state = -1;
					if (<>4__this.enableMod.Value && IsHost() && <>4__this.destroyExistingHealthUpgradeItems.Value)
					{
						<>4__this.DestroySpawnedHealthUpgradeItems();
					}
					break;
				}
				<>2__current = (object)new WaitForSeconds(1f);
				<>1__state = 1;
				return true;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		[CompilerGenerated]
		private sealed class <EnforceLoop>d__34 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public LowHealthChallengePlugin <>4__this;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <EnforceLoop>d__34(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_002c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0036: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					break;
				case 1:
					<>1__state = -1;
					if (<>4__this.enableMod.Value && OverrideActive && IsHost())
					{
						<>4__this.RefreshHealthUpgradeItemsDisabledState();
						if (<>4__this.reapplyHealthOverrideIfChanged.Value)
						{
							ApplyFixedHealthToAllPlayers();
						}
					}
					break;
				}
				<>2__current = (object)new WaitForSeconds(1f);
				<>1__state = 1;
				return true;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		public const string PluginGuid = "REPOJP.LowHealthChallenge";

		public const string PluginName = "LowHealthChallenge";

		public const string PluginVersion = "1.0.0";

		internal static LowHealthChallengePlugin Instance;

		internal static ManualLogSource Log;

		private Harmony harmony;

		private ConfigEntry<bool> enableMod;

		private ConfigEntry<int> targetHealth;

		private ConfigEntry<bool> blockHealthUpgradeInShop;

		private ConfigEntry<bool> blockHealthUpgradeInWorld;

		private ConfigEntry<bool> destroyExistingHealthUpgradeItems;

		private ConfigEntry<bool> reapplyHealthOverrideIfChanged;

		private ConfigEntry<bool> logRoundedResult;

		private bool suppressTargetHealthEvent;

		private Coroutine enforceCoroutine;

		private Coroutine destroyHealthUpgradeCoroutine;

		internal static readonly int[] AllowedHealthValues = new int[6] { 0, 20, 40, 60, 80, 100 };

		internal static bool OverrideActive;

		internal static int RoundedHealthValue = 40;

		internal static int MappedHealthUpgradeValue = -3;

		private void Awake()
		{
			//IL_0118: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: Expected O, but got Unknown
			Instance = this;
			Log = ((BaseUnityPlugin)this).Logger;
			enableMod = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "EnableMod", true, "Enable or disable this mod");
			targetHealth = ((BaseUnityPlugin)this).Config.Bind<int>("Health", "TargetHealth", 40, "Target health input 0-100. This value is always rewritten to the rounded value");
			blockHealthUpgradeInShop = ((BaseUnityPlugin)this).Config.Bind<bool>("Health Upgrade Blocking", "BlockHealthUpgradeInShop", true, "Remove health upgrade from shop candidates");
			blockHealthUpgradeInWorld = ((BaseUnityPlugin)this).Config.Bind<bool>("Health Upgrade Blocking", "BlockHealthUpgradeInWorld", true, "Disable health upgrade items in item dictionary");
			destroyExistingHealthUpgradeItems = ((BaseUnityPlugin)this).Config.Bind<bool>("Health Upgrade Blocking", "DestroyExistingHealthUpgradeItems", true, "Destroy spawned health upgrade items");
			reapplyHealthOverrideIfChanged = ((BaseUnityPlugin)this).Config.Bind<bool>("Health Upgrade Blocking", "ReapplyHealthOverrideIfChanged", false, "Reapply fixed health if changed");
			logRoundedResult = ((BaseUnityPlugin)this).Config.Bind<bool>("Debug", "LogRoundedResult", true, "Log rounded result");
			targetHealth.SettingChanged += OnTargetHealthSettingChanged;
			harmony = new Harmony("REPOJP.LowHealthChallenge");
			harmony.PatchAll();
			NormalizeConfigAndApply("Awake");
			enforceCoroutine = ((MonoBehaviour)this).StartCoroutine(EnforceLoop());
			destroyHealthUpgradeCoroutine = ((MonoBehaviour)this).StartCoroutine(DestroyHealthUpgradeLoop());
			((BaseUnityPlugin)this).Logger.LogInfo((object)"LowHealthChallenge 1.0.0 loaded");
		}

		private void OnDestroy()
		{
			targetHealth.SettingChanged -= OnTargetHealthSettingChanged;
			if (harmony != null)
			{
				harmony.UnpatchSelf();
			}
		}

		private void OnTargetHealthSettingChanged(object sender, EventArgs e)
		{
			if (!suppressTargetHealthEvent)
			{
				NormalizeConfigAndApply("ConfigChanged");
			}
		}

		internal static bool IsHost()
		{
			return SemiFunc.IsMasterClientOrSingleplayer();
		}

		internal static bool TryGetSteamId(PlayerAvatar avatar, out string steamId)
		{
			steamId = null;
			if (!Object.op_Implicit((Object)(object)avatar))
			{
				return false;
			}
			if (!string.IsNullOrWhiteSpace(avatar.steamID))
			{
				steamId = avatar.steamID;
				return true;
			}
			try
			{
				steamId = SemiFunc.PlayerGetSteamID(avatar);
			}
			catch
			{
				steamId = null;
			}
			return !string.IsNullOrWhiteSpace(steamId);
		}

		internal static int NormalizeHealthValue(int input)
		{
			int num = Mathf.Clamp(input, 0, 100);
			int num2 = AllowedHealthValues[0];
			int num3 = Math.Abs(num - num2);
			for (int i = 1; i < AllowedHealthValues.Length; i++)
			{
				int num4 = AllowedHealthValues[i];
				int num5 = Math.Abs(num - num4);
				if (num5 < num3)
				{
					num2 = num4;
					num3 = num5;
				}
				else if (num5 == num3 && num4 > num2)
				{
					num2 = num4;
					num3 = num5;
				}
			}
			return num2;
		}

		internal static int MapRoundedHealthToUpgradeValue(int roundedHealth)
		{
			return (roundedHealth - 100) / 20;
		}

		private void NormalizeConfigAndApply(string source)
		{
			if (!enableMod.Value)
			{
				OverrideActive = false;
				return;
			}
			int value = targetHealth.Value;
			int num = NormalizeHealthValue(value);
			int num2 = MapRoundedHealthToUpgradeValue(num);
			RoundedHealthValue = num;
			MappedHealthUpgradeValue = num2;
			OverrideActive = true;
			WriteRoundedHealthToConfigIfNeeded(num);
			if (logRoundedResult.Value)
			{
				Log.LogInfo((object)$"[{source}] Requested health: {value}");
				Log.LogInfo((object)$"[{source}] Rounded health: {num}");
				Log.LogInfo((object)$"[{source}] Mapped health upgrade: {num2}");
			}
			RefreshHealthUpgradeItemsDisabledState();
			if (IsHost())
			{
				ApplyFixedHealthToAllPlayers();
			}
		}

		private void WriteRoundedHealthToConfigIfNeeded(int rounded)
		{
			if (targetHealth.Value == rounded)
			{
				return;
			}
			suppressTargetHealthEvent = true;
			try
			{
				targetHealth.Value = rounded;
				((BaseUnityPlugin)this).Config.Save();
			}
			finally
			{
				suppressTargetHealthEvent = false;
			}
		}

		internal static void SetTargetHealthFromCommand(int requestedValue)
		{
			if (Object.op_Implicit((Object)(object)Instance))
			{
				int num = NormalizeHealthValue(requestedValue);
				Instance.suppressTargetHealthEvent = true;
				try
				{
					Instance.targetHealth.Value = num;
					((BaseUnityPlugin)Instance).Config.Save();
				}
				finally
				{
					Instance.suppressTargetHealthEvent = false;
				}
				RoundedHealthValue = num;
				MappedHealthUpgradeValue = MapRoundedHealthToUpgradeValue(num);
				OverrideActive = true;
				if (Instance.logRoundedResult.Value)
				{
					Log.LogInfo((object)$"[Command] Requested health: {requestedValue}");
					Log.LogInfo((object)$"[Command] Rounded health: {num}");
					Log.LogInfo((object)$"[Command] Mapped health upgrade: {MappedHealthUpgradeValue}");
				}
				Instance.RefreshHealthUpgradeItemsDisabledState();
				if (IsHost())
				{
					ApplyFixedHealthToAllPlayers();
				}
			}
		}

		private static void ApplyFixedHealthToAllPlayers()
		{
			if (!OverrideActive || !IsHost() || !Object.op_Implicit((Object)(object)GameDirector.instance) || GameDirector.instance.PlayerList == null || !Object.op_Implicit((Object)(object)StatsManager.instance))
			{
				return;
			}
			foreach (PlayerAvatar player in GameDirector.instance.PlayerList)
			{
				ApplyFixedHealthToSinglePlayer(player);
			}
		}

		private static void ApplyFixedHealthToSinglePlayer(PlayerAvatar avatar)
		{
			if (!OverrideActive || !Object.op_Implicit((Object)(object)avatar) || !Object.op_Implicit((Object)(object)StatsManager.instance) || !TryGetSteamId(avatar, out string steamId))
			{
				return;
			}
			string text = avatar.playerName;
			if (string.IsNullOrWhiteSpace(text))
			{
				try
				{
					text = SemiFunc.PlayerGetName(avatar);
				}
				catch
				{
					text = steamId;
				}
			}
			StatsManager.instance.PlayerAdd(steamId, text);
			SetPlayerUpgradeHealth(steamId, MappedHealthUpgradeValue);
			int playerHealth = StatsManager.instance.GetPlayerHealth(steamId);
			int num = ((playerHealth > RoundedHealthValue) ? RoundedHealthValue : playerHealth);
			num = Mathf.Clamp(num, 0, RoundedHealthValue);
			StatsManager.instance.SetPlayerHealth(steamId, num, true);
			ApplyImmediateHealthToAvatar(avatar, num, RoundedHealthValue);
		}

		private static void SetPlayerUpgradeHealth(string steamId, int value)
		{
			if (!StatsManager.instance.playerUpgradeHealth.ContainsKey(steamId))
			{
				StatsManager.instance.playerUpgradeHealth.Add(steamId, value);
			}
			else
			{
				StatsManager.instance.playerUpgradeHealth[steamId] = value;
			}
			if (Object.op_Implicit((Object)(object)PunManager.instance))
			{
				PunManager.instance.UpdateStat("playerUpgradeHealth", steamId, value);
			}
		}

		private static void ApplyImmediateHealthToAvatar(PlayerAvatar avatar, int currentHealth, int maxHealth)
		{
			if (Object.op_Implicit((Object)(object)avatar) && Object.op_Implicit((Object)(object)avatar.playerHealth))
			{
				avatar.playerHealth.maxHealth = maxHealth;
				avatar.playerHealth.health = Mathf.Clamp(currentHealth, 0, maxHealth);
				if (Object.op_Implicit((Object)(object)avatar.playerHealth.photonView))
				{
					avatar.playerHealth.photonView.RPC("UpdateHealthRPC", (RpcTarget)1, new object[3]
					{
						avatar.playerHealth.health,
						avatar.playerHealth.maxHealth,
						false
					});
				}
			}
		}

		[IteratorStateMachine(typeof(<EnforceLoop>d__34))]
		private IEnumerator EnforceLoop()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <EnforceLoop>d__34(0)
			{
				<>4__this = this
			};
		}

		[IteratorStateMachine(typeof(<DestroyHealthUpgradeLoop>d__35))]
		private IEnumerator DestroyHealthUpgradeLoop()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <DestroyHealthUpgradeLoop>d__35(0)
			{
				<>4__this = this
			};
		}

		private void RefreshHealthUpgradeItemsDisabledState()
		{
			if (!enableMod.Value || !IsHost() || !Object.op_Implicit((Object)(object)StatsManager.instance))
			{
				return;
			}
			foreach (Item value in StatsManager.instance.itemDictionary.Values)
			{
				if (Object.op_Implicit((Object)(object)value) && IsHealthUpgradeItem(value) && blockHealthUpgradeInWorld.Value)
				{
					value.disabled = true;
				}
			}
		}

		private static bool IsHealthUpgradeItem(Item item)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Invalid comparison between Unknown and I4
			if (!Object.op_Implicit((Object)(object)item))
			{
				return false;
			}
			if ((int)item.itemType != 3)
			{
				return false;
			}
			if (item.prefab == null || !item.prefab.IsValid())
			{
				return false;
			}
			GameObject val = null;
			try
			{
				val = item.prefab.Prefab;
			}
			catch
			{
				val = null;
			}
			if (!Object.op_Implicit((Object)(object)val))
			{
				return false;
			}
			return (Object)(object)val.GetComponentInChildren<ItemUpgradePlayerHealth>(true) != (Object)null;
		}

		private void DestroySpawnedHealthUpgradeItems()
		{
			if (!destroyExistingHealthUpgradeItems.Value)
			{
				return;
			}
			ItemUpgradePlayerHealth[] array = Object.FindObjectsOfType<ItemUpgradePlayerHealth>(true);
			ItemUpgradePlayerHealth[] array2 = array;
			foreach (ItemUpgradePlayerHealth val in array2)
			{
				if (!Object.op_Implicit((Object)(object)val))
				{
					continue;
				}
				GameObject gameObject = ((Component)val).gameObject;
				PhotonView componentInParent = gameObject.GetComponentInParent<PhotonView>();
				if (Object.op_Implicit((Object)(object)componentInParent) && Object.op_Implicit((Object)(object)((Component)componentInParent).gameObject))
				{
					gameObject = ((Component)componentInParent).gameObject;
				}
				try
				{
					if (Object.op_Implicit((Object)(object)componentInParent) && PhotonNetwork.InRoom)
					{
						PhotonNetwork.Destroy(gameObject);
					}
					else
					{
						Object.Destroy((Object)(object)gameObject);
					}
				}
				catch
				{
					try
					{
						Object.Destroy((Object)(object)gameObject);
					}
					catch
					{
					}
				}
			}
		}

		internal static void ExecuteCommand(string rawMessage)
		{
			if (!Object.op_Implicit((Object)(object)Instance) || !Instance.enableMod.Value || !IsHost() || string.IsNullOrWhiteSpace(rawMessage))
			{
				return;
			}
			string text = rawMessage.Trim();
			if (string.Equals(text, "/hpnow", StringComparison.OrdinalIgnoreCase))
			{
				Log.LogInfo((object)$"Current TargetHealth(Config): {Instance.targetHealth.Value}");
				Log.LogInfo((object)$"Current RoundedHealthValue: {RoundedHealthValue}");
				Log.LogInfo((object)$"Current MappedHealthUpgradeValue: {MappedHealthUpgradeValue}");
			}
			else if (string.Equals(text, "/hpreset", StringComparison.OrdinalIgnoreCase))
			{
				SetTargetHealthFromCommand(100);
			}
			else if (text.StartsWith("/hpset ", StringComparison.OrdinalIgnoreCase))
			{
				string text2 = text.Substring(7).Trim();
				if (!int.TryParse(text2, out var result))
				{
					Log.LogInfo((object)("Invalid /hpset value: " + text2));
				}
				else
				{
					SetTargetHealthFromCommand(result);
				}
			}
		}

		[IteratorStateMachine(typeof(<DelayedReapplyAfterLevelChange>d__45))]
		private IEnumerator DelayedReapplyAfterLevelChange()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <DelayedReapplyAfterLevelChange>d__45(0)
			{
				<>4__this = this
			};
		}
	}
}