using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
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 HarmonyLib;
using Microsoft.CodeAnalysis;
using Service;
using UnityEngine;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: AssemblyCompany("DPS")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("DPS")]
[assembly: AssemblyTitle("DPS")]
[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;
		}
	}
}
internal sealed class ConfigurationManagerAttributes
{
	public bool? ShowRangeAsPercent;

	public Action<ConfigEntryBase> CustomDrawer;

	public bool? Browsable;

	public string Category;

	public object DefaultValue;

	public bool? HideDefaultButton;

	public bool? HideSettingName;

	public string Description;

	public string DispName;

	public int? Order;

	public bool? ReadOnly;

	public bool? IsAdvanced;

	public Func<object, string> ObjToStr;

	public Func<string, object> StrToObj;
}
namespace Service
{
	public class Format
	{
		public const string FORMAT = "0.##";

		public static string GetValidColor(bool valid)
		{
			if (!valid)
			{
				return "grey";
			}
			return "yellow";
		}

		public static string String(string value, string color = "yellow")
		{
			return "<color=" + color + ">" + value + "</color>";
		}

		public static string String(string value, bool valid)
		{
			return "<color=" + GetValidColor(valid) + ">" + value + "</color>";
		}

		public static string Float(double value, string format = "0.##", string color = "yellow")
		{
			return String(value.ToString(format, CultureInfo.InvariantCulture), color);
		}

		public static string Multiplier(double value, string color = "yellow")
		{
			return String(value.ToString("0.##", CultureInfo.InvariantCulture) + "x", color);
		}

		public static string Meters(double value, string color = "yellow")
		{
			return String(value.ToString("0.##", CultureInfo.InvariantCulture) + " meters", color);
		}

		public static string Degrees(double value, string color = "yellow")
		{
			return String(value.ToString("0.##", CultureInfo.InvariantCulture) + " degrees", color);
		}

		public static string Fixed(double value)
		{
			return String(value.ToString("N2", CultureInfo.InvariantCulture).PadLeft(5, '0'));
		}

		public static string Percent(double value, string color = "yellow")
		{
			return String((100.0 * value).ToString("0.##", CultureInfo.InvariantCulture) + " %", color);
		}

		public static string PercentInt(double value, string color = "yellow")
		{
			return String(value.ToString("P0", CultureInfo.InvariantCulture), color);
		}

		public static string Range(double min, double max, string color = "yellow")
		{
			if (min == max)
			{
				return String(max.ToString("0.##", CultureInfo.InvariantCulture), color);
			}
			return String(min.ToString("0.##", CultureInfo.InvariantCulture), color) + "-" + String(max.ToString("0.##", CultureInfo.InvariantCulture), color);
		}

		public static string PercentRange(double min, double max)
		{
			if (min == max)
			{
				return max.ToString("P0", CultureInfo.InvariantCulture);
			}
			return min.ToString("P0", CultureInfo.InvariantCulture) + "-" + max.ToString("P0", CultureInfo.InvariantCulture);
		}

		public static string Progress(double value, double limit, bool percent = false)
		{
			return String(value.ToString("N0")) + "/" + String(limit.ToString("N0")) + (percent ? (" (" + PercentInt(value / limit) + ")") : "");
		}

		public static string Int(double value, string color = "yellow")
		{
			return String(value.ToString("N0"), color);
		}

		public static string ProgressPercent(string header, double value, double limit)
		{
			return header + ": " + Progress(value, limit) + " seconds (" + Percent(value / limit) + ")";
		}

		public static string JoinLines(IEnumerable<string> lines)
		{
			return string.Join("\n", lines.Where((string line) => line != ""));
		}

		public static string JoinRow(IEnumerable<string> lines)
		{
			return string.Join(", ", lines.Where((string line) => line != ""));
		}
	}
	[HarmonyPatch(typeof(MessageHud), "Update")]
	public class MessageHud_UpdateMessage : MonoBehaviour
	{
		public static Func<List<string>> GetMessage = () => new List<string> { "Default test. Replace with own function." };

		private static void Postfix(MessageHud __instance)
		{
			if ((Object)(object)Player.m_localPlayer == (Object)null || Hud.IsUserHidden())
			{
				return;
			}
			string text = __instance.m_messageText.text;
			List<string> list = GetMessage();
			if (list.Count != 0)
			{
				while (text.StartsWith(" \n"))
				{
					text = text.Substring(2);
				}
				int num = ((text != "") ? text.Split(new char[1] { '\n' }).Length : 0) + list.Count - 2;
				for (int i = 0; i < num; i++)
				{
					list.Insert(0, " ");
				}
				if (text != "")
				{
					list.Insert(0, " ");
					list.Insert(0, " ");
					list.Add(" ");
					list.Add(text);
				}
				__instance.m_messageText.text = Format.JoinLines(list);
				((Graphic)__instance.m_messageText).CrossFadeAlpha(1f, 0f, true);
				((Graphic)__instance.m_messageIcon).canvasRenderer.SetAlpha(0f);
				((Graphic)__instance.m_messageIcon).CrossFadeAlpha(0f, 0f, true);
			}
		}
	}
	[HarmonyPatch(typeof(MessageHud), "UpdateMessage")]
	public class MessageHud_GetBaseMessage : MonoBehaviour
	{
		private static string BaseMessage = "";

		private static void Prefix(out string __state)
		{
			__state = MessageHud.instance.m_messageText.text;
		}

		private static void Postfix(MessageHud __instance, float ___m_msgQueueTimer, string __state)
		{
			if (__instance.m_messageText.text != __state)
			{
				BaseMessage = __instance.m_messageText.text;
			}
			if (___m_msgQueueTimer >= 4f)
			{
				BaseMessage = "";
			}
			__instance.m_messageText.text = BaseMessage;
		}
	}
}
namespace DPS
{
	[HarmonyPatch(typeof(Skills), "GetSkillFactor")]
	public class Skills_GetSkillFactor
	{
		public static void Postfix(ref float __result)
		{
			if (!(Settings.SetSkills < 0f))
			{
				__result = Settings.SetSkills;
			}
		}
	}
	[HarmonyPatch(typeof(Skills), "GetRandomSkillRange")]
	public class Skills_GetRandomSkillRange
	{
		public static void Postfix(Skills __instance, out float min, out float max, SkillType skillType)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			float num = ((Settings.PlayerDamageRange >= 0f) ? Settings.PlayerDamageRange : 0.15f);
			float skillFactor = __instance.GetSkillFactor(skillType);
			float num2 = Mathf.Lerp(0.4f, 1f, skillFactor);
			max = Mathf.Clamp01(num2 + num);
			min = Mathf.Clamp01(num2 - num);
		}
	}
	[HarmonyPatch(typeof(Skills), "GetRandomSkillFactor")]
	public class Skills_GetRandomSkillFactor
	{
		private static void Postfix(Skills __instance, ref float __result, SkillType skillType)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			if (!(Settings.PlayerDamageRange < 0f))
			{
				float skillFactor = __instance.GetSkillFactor(skillType);
				float num = Mathf.Lerp(0.4f, 1f, skillFactor);
				float num2 = Mathf.Clamp01(num - Settings.PlayerDamageRange);
				float num3 = Mathf.Clamp01(num + Settings.PlayerDamageRange);
				__result = Mathf.Lerp(num2, num3, Random.value);
			}
		}
	}
	[HarmonyPatch(typeof(Character), "GetRandomSkillFactor")]
	public class Character_GetRandomSkillFactor
	{
		private static void Postfix(ref float __result)
		{
			if (!(Settings.CreatureDamageRange < 0f))
			{
				__result = Random.Range(1f - Settings.CreatureDamageRange, 1f);
			}
		}
	}
	[HarmonyPatch(typeof(Player), "RPC_UseStamina")]
	public class Player_RPC_UseStamina
	{
		private static void Prefix(ref float v)
		{
			if (Settings.NoStaminaUsage)
			{
				v = 0f;
			}
		}
	}
	[HarmonyPatch(typeof(Attack), "Start")]
	public class Attack_Start_CapChain
	{
		private static void Prefix(ref Attack? previousAttack, ref int ___m_currentAttackCainLevel)
		{
			if (Settings.MaxAttackChainLevels >= 0 && previousAttack != null && previousAttack.m_nextAttackChainLevel >= Settings.MaxAttackChainLevels)
			{
				previousAttack = null;
				___m_currentAttackCainLevel = 0;
			}
		}
	}
	[HarmonyPatch(typeof(Player), "PlayerAttackInput")]
	public class AutoShootBow
	{
		private static void Prefix(Player __instance)
		{
			if (!((Character)__instance).InPlaceMode() && Settings.AutoFireBow)
			{
				ItemData currentWeapon = ((Humanoid)__instance).GetCurrentWeapon();
				if (currentWeapon != null && !(currentWeapon.m_shared.m_attack.m_drawDurationMin <= 0f) && !(((Humanoid)__instance).GetAttackDrawPercentage() < 1f))
				{
					((Character)__instance).m_attackHold = false;
				}
			}
		}
	}
	[BepInPlugin("dps", "DPS", "1.6")]
	public class DPS : BaseUnityPlugin
	{
		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static ConsoleEvent <>9__6_0;

			public static ConsoleEvent <>9__6_1;

			public static ConsoleEvent <>9__6_2;

			public static ConsoleEvent <>9__6_3;

			public static ConsoleEvent <>9__6_4;

			internal void <InitCommands>b__6_0(ConsoleEventArgs args)
			{
				if (Settings.ShowDPS && DPSMeter.Running)
				{
					DPSMeter.Reset();
					args.Context.AddString("DPS tool reseted.");
				}
				else
				{
					Settings.configShowDPS.Value = !Settings.ShowDPS;
					args.Context.AddString("DPS tool " + (Settings.ShowDPS ? "enabled" : "disabled") + ".");
				}
			}

			internal void <InitCommands>b__6_1(ConsoleEventArgs args)
			{
				if (Settings.ShowExperience && ExperienceMeter.Running)
				{
					ExperienceMeter.Reset();
					args.Context.AddString("Experience tool reseted.");
				}
				else
				{
					Settings.configShowExperience.Value = !Settings.ShowExperience;
					args.Context.AddString("Experience tool " + (Settings.ShowExperience ? "enabled" : "disabled") + ".");
				}
			}

			internal void <InitCommands>b__6_2(ConsoleEventArgs args)
			{
				if (!Settings.IsCheats)
				{
					AddMessage(args.Context, "Unauthorized to spawn dummies.");
					return;
				}
				Dummy.Spawn(args.Args);
				((Character)Player.m_localPlayer).Message((MessageType)1, "Spawned a training dummy", 0, (Sprite)null);
			}

			internal void <InitCommands>b__6_3(ConsoleEventArgs args)
			{
				if (!Settings.IsCheats)
				{
					AddMessage(args.Context, "Unauthorized to kill dummies.");
					return;
				}
				int num = Dummy.Kill();
				((Character)Player.m_localPlayer).Message((MessageType)1, "Killing all training dummies:" + num, 0, (Sprite)null);
			}

			internal void <InitCommands>b__6_4(ConsoleEventArgs args)
			{
				if (!Settings.IsCheats)
				{
					AddMessage(args.Context, "Unauthorized to spawn dummies.");
					return;
				}
				Dummy.Kill();
				Dummy.Spawn(args.Args);
				((Character)Player.m_localPlayer).Message((MessageType)1, "Spawned a training dummy", 0, (Sprite)null);
			}
		}

		public const string GUID = "dps";

		public const string NAME = "DPS";

		public const string VERSION = "1.6";

		public void Awake()
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			Settings.Init(((BaseUnityPlugin)this).Config);
			new Harmony("dps").PatchAll();
			InitCommands();
			MessageHud_UpdateMessage.GetMessage = GetMessage;
		}

		private static List<string> GetMessage()
		{
			List<string> list = new List<string>();
			List<string> list2 = DPSMeter.Get();
			List<string> list3 = ExperienceMeter.Get();
			if (list2 != null || list3 != null)
			{
				if (Settings.CheatsRequired())
				{
					list.Add(Format.String("No cheat access, some features won't work.", "red"));
				}
				else
				{
					if (Settings.CreatureDamageRange >= 0f)
					{
						list.Add("Creature damage range: " + Format.Percent(Settings.CreatureDamageRange));
					}
					if (Settings.MaxAttackChainLevels >= 0)
					{
						list.Add("Max attack chain: " + Format.Int(Settings.MaxAttackChainLevels));
					}
					if (Settings.PlayerDamageRange >= 0f)
					{
						list.Add("Player damage range: " + Format.Percent(Settings.PlayerDamageRange));
					}
					if (Settings.NoStaminaUsage)
					{
						list.Add("No stamina usage");
					}
					if (Settings.SetSkills >= 0f)
					{
						list.Add("Override skills: " + Format.Int(Settings.SetSkills * 100f));
					}
				}
			}
			if (list2 != null)
			{
				list.Add(" ");
				list.AddRange(list2);
			}
			if (list3 != null)
			{
				list.Add(" ");
				list.AddRange(list3);
			}
			return list;
		}

		public static void AddMessage(Terminal context, string message)
		{
			context.AddString(message);
			if (Object.op_Implicit((Object)(object)MessageHud.instance))
			{
				Player localPlayer = Player.m_localPlayer;
				if (localPlayer != null)
				{
					((Character)localPlayer).Message((MessageType)1, message, 0, (Sprite)null);
				}
			}
		}

		private static void InitCommands()
		{
			//IL_0032: 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_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Expected O, but got Unknown
			//IL_006a: 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_0061: Expected O, but got Unknown
			//IL_00a2: 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_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Expected O, but got Unknown
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Expected O, but got Unknown
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			//IL_0109: Expected O, but got Unknown
			object obj = <>c.<>9__6_0;
			if (obj == null)
			{
				ConsoleEvent val = delegate(ConsoleEventArgs args)
				{
					if (Settings.ShowDPS && DPSMeter.Running)
					{
						DPSMeter.Reset();
						args.Context.AddString("DPS tool reseted.");
					}
					else
					{
						Settings.configShowDPS.Value = !Settings.ShowDPS;
						args.Context.AddString("DPS tool " + (Settings.ShowDPS ? "enabled" : "disabled") + ".");
					}
				};
				<>c.<>9__6_0 = val;
				obj = (object)val;
			}
			new ConsoleCommand("dps", "Toggles DPS tool.", (ConsoleEvent)obj, false, false, false, false, false, (ConsoleOptionsFetcher)null, false, false, false);
			object obj2 = <>c.<>9__6_1;
			if (obj2 == null)
			{
				ConsoleEvent val2 = delegate(ConsoleEventArgs args)
				{
					if (Settings.ShowExperience && ExperienceMeter.Running)
					{
						ExperienceMeter.Reset();
						args.Context.AddString("Experience tool reseted.");
					}
					else
					{
						Settings.configShowExperience.Value = !Settings.ShowExperience;
						args.Context.AddString("Experience tool " + (Settings.ShowExperience ? "enabled" : "disabled") + ".");
					}
				};
				<>c.<>9__6_1 = val2;
				obj2 = (object)val2;
			}
			new ConsoleCommand("exp", "Toggles experience tool.", (ConsoleEvent)obj2, false, false, false, false, false, (ConsoleOptionsFetcher)null, false, false, false);
			object obj3 = <>c.<>9__6_2;
			if (obj3 == null)
			{
				ConsoleEvent val3 = delegate(ConsoleEventArgs args)
				{
					if (!Settings.IsCheats)
					{
						AddMessage(args.Context, "Unauthorized to spawn dummies.");
					}
					else
					{
						Dummy.Spawn(args.Args);
						((Character)Player.m_localPlayer).Message((MessageType)1, "Spawned a training dummy", 0, (Sprite)null);
					}
				};
				<>c.<>9__6_2 = val3;
				obj3 = (object)val3;
			}
			new ConsoleCommand("dummy_spawn", "[resistance1=modifier1] [resistance2=modifier2]... - Spawns a training dummy.", (ConsoleEvent)obj3, false, false, false, false, false, (ConsoleOptionsFetcher)null, false, false, false);
			object obj4 = <>c.<>9__6_3;
			if (obj4 == null)
			{
				ConsoleEvent val4 = delegate(ConsoleEventArgs args)
				{
					if (!Settings.IsCheats)
					{
						AddMessage(args.Context, "Unauthorized to kill dummies.");
					}
					else
					{
						int num = Dummy.Kill();
						((Character)Player.m_localPlayer).Message((MessageType)1, "Killing all training dummies:" + num, 0, (Sprite)null);
					}
				};
				<>c.<>9__6_3 = val4;
				obj4 = (object)val4;
			}
			new ConsoleCommand("dummy_kill", "Kills all training dummies.", (ConsoleEvent)obj4, false, false, false, false, false, (ConsoleOptionsFetcher)null, false, false, false);
			object obj5 = <>c.<>9__6_4;
			if (obj5 == null)
			{
				ConsoleEvent val5 = delegate(ConsoleEventArgs args)
				{
					if (!Settings.IsCheats)
					{
						AddMessage(args.Context, "Unauthorized to spawn dummies.");
					}
					else
					{
						Dummy.Kill();
						Dummy.Spawn(args.Args);
						((Character)Player.m_localPlayer).Message((MessageType)1, "Spawned a training dummy", 0, (Sprite)null);
					}
				};
				<>c.<>9__6_4 = val5;
				obj5 = (object)val5;
			}
			new ConsoleCommand("dummy_reset", "[resistance1=modifier1] [resistance2=modifier2]... - Kills all training dummies and spawns a new one.", (ConsoleEvent)obj5, false, false, false, false, false, (ConsoleOptionsFetcher)null, false, false, false);
		}
	}
	internal class Stats
	{
		public float Hits;

		public float Damage;

		public float StructureDamage;

		public float Staggering;

		public float TotalStamina;

		public float Stamina;

		public float DamagePerStamina
		{
			get
			{
				if (!(Stamina > 0f))
				{
					return 0f;
				}
				return Damage / Stamina;
			}
		}

		public float StructureDamagePerStamina
		{
			get
			{
				if (!(Stamina > 0f))
				{
					return 0f;
				}
				return StructureDamage / Stamina;
			}
		}

		public static Stats operator +(Stats a, Stats b)
		{
			return new Stats
			{
				Hits = a.Hits + b.Hits,
				Damage = a.Damage + b.Damage,
				StructureDamage = a.StructureDamage + b.StructureDamage,
				Staggering = a.Staggering + b.Staggering,
				TotalStamina = a.TotalStamina + b.TotalStamina,
				Stamina = a.Stamina + b.Stamina
			};
		}

		public static Stats operator *(Stats a, float b)
		{
			return new Stats
			{
				Hits = a.Hits * b,
				Damage = a.Damage * b,
				StructureDamage = a.StructureDamage * b,
				Staggering = a.Staggering * b,
				TotalStamina = a.TotalStamina * b,
				Stamina = a.Stamina * b
			};
		}
	}
	public class DPSMeter
	{
		private static DateTime? startTime = null;

		private static DateTime? endTime = null;

		private static float damageTaken = 0f;

		private static Stats stats = new Stats();

		private static Stats pending = new Stats();

		public static bool Running => startTime.HasValue;

		public static void Start()
		{
			if (Settings.ShowDPS && !startTime.HasValue)
			{
				Reset();
				startTime = DateTime.Now;
			}
		}

		public static void Reset()
		{
			startTime = null;
			endTime = null;
			damageTaken = 0f;
			stats = new Stats();
			pending = new Stats();
		}

		private static void AddStructureDamage(HitData hit, int tooltier)
		{
			if (startTime.HasValue && !(hit.m_damage.m_damage > 1E+09f) && hit.m_toolTier >= tooltier)
			{
				pending.StructureDamage += hit.GetTotalDamage();
			}
		}

		public static void AddStructureDamage(HitData hit)
		{
			AddStructureDamage(hit, 0);
		}

		public static void AddStructureDamage(HitData hit, TreeLog obj)
		{
			AddStructureDamage(hit, obj.m_minToolTier);
		}

		public static void AddStructureDamage(HitData hit, TreeBase obj)
		{
			AddStructureDamage(hit, obj.m_minToolTier);
		}

		public static void AddStructureDamage(HitData hit, MineRock5 obj)
		{
			AddStructureDamage(hit, obj.m_minToolTier);
		}

		public static void AddStructureDamage(HitData hit, MineRock obj)
		{
			AddStructureDamage(hit, obj.m_minToolTier);
		}

		public static void AddStructureDamage(HitData hit, Destructible obj)
		{
			AddStructureDamage(hit, obj.m_minToolTier);
		}

		public static void AddDamageTaken(HitData hit)
		{
			if (startTime.HasValue)
			{
				damageTaken += hit.GetTotalDamage();
				SetTime();
			}
		}

		public static void AddDamage(HitData hit)
		{
			if (startTime.HasValue && !(hit.m_damage.m_damage > 1E+09f))
			{
				pending.Damage += hit.GetTotalDamage();
				pending.Staggering += ((DamageTypes)(ref hit.m_damage)).GetTotalStaggerDamage() * hit.m_staggerMultiplier;
			}
		}

		public static void AddDot(HitData hit)
		{
			if (startTime.HasValue && !(hit.m_damage.m_damage > 1E+09f))
			{
				pending.Damage += hit.GetTotalDamage();
			}
		}

		public static void AddStamina(float stamina)
		{
			if (startTime.HasValue)
			{
				pending.Stamina += stamina;
			}
		}

		public static void AddHit()
		{
			if (startTime.HasValue)
			{
				pending.Hits += 1f;
			}
		}

		public static void AddTotalStamina(float stamina)
		{
			if (startTime.HasValue)
			{
				pending.TotalStamina += stamina;
			}
		}

		public static void SetTime()
		{
			if (startTime.HasValue)
			{
				endTime = DateTime.Now;
				stats += pending;
				pending = new Stats();
			}
		}

		public static List<string>? Get()
		{
			if (!Settings.ShowDPS)
			{
				return null;
			}
			double num = 1E-05;
			if (startTime.HasValue && endTime.HasValue)
			{
				num = endTime.Value.Subtract(startTime.Value).TotalSeconds;
			}
			float num2 = 1f / (float)num;
			Stats stats = DPSMeter.stats * num2;
			Stats stats2 = DPSMeter.stats + pending;
			float num3 = ((stats.Hits > 0f) ? (1f / stats.Hits) : 0f);
			List<string> list = new List<string>();
			list.Add("Time: " + Format.Float(num) + " seconds with " + Format.Float(DPSMeter.stats.Hits) + " hits");
			list.Add("DPS: " + Format.Float(stats.Damage) + " (total " + Format.Float(stats2.Damage) + "), per stamina: " + Format.Float(DPSMeter.stats.DamagePerStamina));
			list.Add("Stamina: " + Format.Float(stats.Stamina) + " (total " + Format.Float(stats2.Stamina) + ")");
			List<string> list2 = list;
			if (DPSMeter.stats.TotalStamina != DPSMeter.stats.Stamina)
			{
				list2.Add("Total stamina: " + Format.Float(stats.TotalStamina) + " (total " + Format.Float(stats2.TotalStamina) + ")");
			}
			list2.Add("Staggering: " + Format.Float(stats.Staggering) + " (total " + Format.Float(stats2.Staggering) + ")");
			list2.Add("Attack speed: " + Format.Float(stats.Hits) + " (" + Format.Float(num3) + " s per attack)");
			if (damageTaken > 0f)
			{
				list2.Add("Damage taken: " + Format.Float(damageTaken * num2) + " (total " + Format.Float(damageTaken) + ")");
			}
			if (DPSMeter.stats.StructureDamage > 0f)
			{
				list2.Add("Structure DPS: " + Format.Float(stats.StructureDamage) + " (total " + Format.Float(stats2.StructureDamage) + "), per stamina: " + Format.Float(DPSMeter.stats.StructureDamagePerStamina));
			}
			return list2;
		}
	}
	[HarmonyPatch(typeof(Attack), "Start")]
	public class Attack_Start
	{
		private static void Postfix(Attack __instance, Humanoid character, bool __result)
		{
			if (__result && (Object)(object)character == (Object)(object)Player.m_localPlayer)
			{
				DPSMeter.Start();
				DPSMeter.AddStamina(__instance.GetAttackStamina());
				DPSMeter.AddHit();
			}
		}
	}
	[HarmonyPatch(typeof(Attack), "Stop")]
	public class Attack_OnAttackStop
	{
		private static void Postfix(Humanoid ___m_character)
		{
			if ((Object)(object)___m_character == (Object)(object)Player.m_localPlayer)
			{
				DPSMeter.SetTime();
			}
		}
	}
	[HarmonyPatch(typeof(Destructible), "RPC_Damage")]
	public class Destructible_RPC_Damage
	{
		private static void Postfix(Destructible __instance, HitData hit)
		{
			if ((Object)(object)hit.GetAttacker() == (Object)(object)Player.m_localPlayer)
			{
				DPSMeter.AddStructureDamage(hit, __instance);
			}
		}
	}
	[HarmonyPatch(typeof(MineRock), "RPC_Hit")]
	public class MineRock_RPC_Hit
	{
		private static void Postfix(MineRock __instance, HitData hit)
		{
			if ((Object)(object)hit.GetAttacker() == (Object)(object)Player.m_localPlayer)
			{
				DPSMeter.AddStructureDamage(hit, __instance);
			}
		}
	}
	[HarmonyPatch(typeof(WearNTear), "RPC_Damage")]
	public class WearNTear_RPC_Damage
	{
		private static void Postfix(HitData hit)
		{
			if ((Object)(object)hit.GetAttacker() == (Object)(object)Player.m_localPlayer)
			{
				DPSMeter.AddStructureDamage(hit);
			}
		}
	}
	[HarmonyPatch(typeof(MineRock5), "DamageArea")]
	public class MineRock5_DamageArea
	{
		private static void Postfix(MineRock5 __instance, HitData hit)
		{
			if ((Object)(object)hit.GetAttacker() == (Object)(object)Player.m_localPlayer)
			{
				DPSMeter.AddStructureDamage(hit, __instance);
			}
		}
	}
	[HarmonyPatch(typeof(TreeBase), "RPC_Damage")]
	public class TreeBase_RPC_Damage
	{
		private static void Postfix(TreeBase __instance, HitData hit)
		{
			if ((Object)(object)hit.GetAttacker() == (Object)(object)Player.m_localPlayer)
			{
				DPSMeter.AddStructureDamage(hit, __instance);
			}
		}
	}
	[HarmonyPatch(typeof(TreeLog), "RPC_Damage")]
	public class TreeLog_RPC_Damage
	{
		private static void Postfix(TreeLog __instance, HitData hit)
		{
			if ((Object)(object)hit.GetAttacker() == (Object)(object)Player.m_localPlayer)
			{
				DPSMeter.AddStructureDamage(hit, __instance);
			}
		}
	}
	[HarmonyPatch(typeof(Character), "ApplyDamage")]
	public class Character_ApplyDamage
	{
		private static void Prefix(Character __instance, HitData hit)
		{
			if ((Object)(object)hit.GetAttacker() == (Object)(object)Player.m_localPlayer)
			{
				DPSMeter.AddDamage(hit);
			}
			if ((Object)(object)hit.GetAttacker() == (Object)null)
			{
				DPSMeter.AddDot(hit);
			}
			if ((Object)(object)__instance == (Object)(object)Player.m_localPlayer)
			{
				DPSMeter.AddDamageTaken(hit);
			}
		}
	}
	[HarmonyPatch(typeof(Player), "UseStamina")]
	public class Player_UseStamina
	{
		private static void Prefix(Player __instance, float v)
		{
			if ((Object)(object)__instance == (Object)(object)Player.m_localPlayer)
			{
				DPSMeter.AddTotalStamina(v);
			}
		}
	}
	public class Dummy
	{
		private static Character Create()
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			return Object.Instantiate<GameObject>(ZNetScene.instance.GetPrefab("TrainingDummy"), ((Component)Player.m_localPlayer).transform.position + ((Component)Player.m_localPlayer).transform.forward * 2f + Vector3.up, Quaternion.identity).GetComponent<Character>();
		}

		private static DamageModifier GetModifier(string value)
		{
			//IL_0218: Unknown result type (might be due to invalid IL or missing references)
			//IL_0219: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0214: Unknown result type (might be due to invalid IL or missing references)
			//IL_020c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0200: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0204: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0210: Unknown result type (might be due to invalid IL or missing references)
			//IL_0208: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e8: Unknown result type (might be due to invalid IL or missing references)
			value = value.Trim().ToLower();
			return (DamageModifier)(value switch
			{
				"ignore" => 4, 
				"weak" => 2, 
				"veryweak" => 6, 
				"resistant" => 1, 
				"veryresistant" => 5, 
				"normal" => 0, 
				"immune" => 3, 
				"-" => 4, 
				"1.5" => 2, 
				"2.0" => 6, 
				"2" => 6, 
				"0.5" => 1, 
				"0.25" => 5, 
				"1.0" => 0, 
				"1" => 0, 
				"0.0" => 3, 
				"0" => 3, 
				_ => 0, 
			});
		}

		public static void Spawn(string[] args)
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: 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_005a: 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_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_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_011e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0125: Expected O, but got I4
			//IL_012a: Expected O, but got I4
			//IL_00ff->IL00ff: Incompatible stack types: O vs I4
			//IL_00f6->IL00ff: Incompatible stack types: I4 vs O
			//IL_00f6->IL00ff: Incompatible stack types: O vs I4
			Character val = Create();
			BaseAI component = ((Component)val).GetComponent<BaseAI>();
			if (Object.op_Implicit((Object)(object)component))
			{
				component.SetHuntPlayer(true);
			}
			SEMan sEMan = val.GetSEMan();
			val.m_damageModifiers.m_blunt = (DamageModifier)0;
			val.m_damageModifiers.m_chop = (DamageModifier)4;
			val.m_damageModifiers.m_fire = (DamageModifier)0;
			val.m_damageModifiers.m_frost = (DamageModifier)0;
			val.m_damageModifiers.m_lightning = (DamageModifier)0;
			val.m_damageModifiers.m_pickaxe = (DamageModifier)4;
			val.m_damageModifiers.m_pierce = (DamageModifier)0;
			val.m_damageModifiers.m_poison = (DamageModifier)0;
			val.m_damageModifiers.m_slash = (DamageModifier)0;
			val.m_damageModifiers.m_spirit = (DamageModifier)0;
			foreach (string item in args.OrderBy((string item) => item))
			{
				string[] array = item.Split(new char[1] { '=' });
				object obj = array[0].ToLower();
				int num;
				if (array.Length > 1)
				{
					obj = GetModifier(array[1]);
					num = (int)obj;
				}
				else
				{
					num = 0;
					obj = num;
					num = (int)obj;
				}
				DamageModifier modifier = (DamageModifier)obj;
				int result;
				bool flag = int.TryParse((array.Length > 1) ? array[1] : "", out result);
				UpdateModifier((string)num, val, modifier);
				string statusEffect = GetStatusEffect((string)num);
				if (statusEffect != "")
				{
					StatusEffect val2 = sEMan.AddStatusEffect(StringExtensionMethods.GetStableHashCode(statusEffect), true, 0, 0f);
					if (flag)
					{
						val2.m_ttl = result;
					}
				}
			}
		}

		private static string GetStatusEffect(string value)
		{
			value = value.Trim().ToLower();
			return value switch
			{
				"cold" => "Cold", 
				"corpserun" => "CorpseRun", 
				"freezing" => "Freezing", 
				"shield" => "GoblinShaman_shield", 
				"bonemass" => "GP_Bonemass", 
				"eikthyr" => "GP_Eikthyr", 
				"moder" => "GP_Moder", 
				"elder" => "GP_TheElder", 
				"yagluth" => "GP_Yagluth", 
				"barleywine" => "Potion_barleywine", 
				"frostresist" => "Potion_frostresist", 
				"poisonresist" => "Potion_poisonresist", 
				"tared" => "Tared", 
				"wet" => "Wet", 
				_ => "", 
			};
		}

		private static void UpdateModifier(string type, Character character, DamageModifier modifier)
		{
			//IL_0020: 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_0046: 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_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: 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_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_012a: Unknown result type (might be due to invalid IL or missing references)
			//IL_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0150: Unknown result type (might be due to invalid IL or missing references)
			//IL_0151: 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_0177: Unknown result type (might be due to invalid IL or missing references)
			if (type == "*" || type == "blunt")
			{
				character.m_damageModifiers.m_blunt = modifier;
			}
			if (type == "*" || type == "chop")
			{
				character.m_damageModifiers.m_chop = modifier;
			}
			if (type == "*" || type == "fire")
			{
				character.m_damageModifiers.m_fire = modifier;
			}
			if (type == "*" || type == "frost")
			{
				character.m_damageModifiers.m_frost = modifier;
			}
			if (type == "*" || type == "lightning")
			{
				character.m_damageModifiers.m_lightning = modifier;
			}
			if (type == "*" || type == "pickaxe")
			{
				character.m_damageModifiers.m_pickaxe = modifier;
			}
			if (type == "*" || type == "pierce")
			{
				character.m_damageModifiers.m_pierce = modifier;
			}
			if (type == "*" || type == "poison")
			{
				character.m_damageModifiers.m_poison = modifier;
			}
			if (type == "*" || type == "slash")
			{
				character.m_damageModifiers.m_slash = modifier;
			}
			if (type == "*" || type == "spirit")
			{
				character.m_damageModifiers.m_spirit = modifier;
			}
		}

		public static int Kill()
		{
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Expected O, but got Unknown
			IEnumerable<Character> enumerable = from item in Character.GetAllCharacters()
				where item.m_name.ToLower() == "trainingdummy"
				select item;
			foreach (Character item in enumerable)
			{
				HitData val = new HitData();
				val.m_damage.m_damage = 1E+10f;
				item.Damage(val);
			}
			return enumerable.Count();
		}
	}
	[HarmonyPatch(typeof(Skill), "Raise")]
	public class Skill_Raise
	{
		private static void Prefix(Skill __instance, float factor)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			ExperienceMeter.AddExperience(__instance.m_info.m_skill, factor * __instance.m_info.m_increseStep);
		}
	}
	public class ExperienceMeter
	{
		private static DateTime? startTime = null;

		private static DateTime? endTime = null;

		private static readonly Dictionary<SkillType, float> experiences = new Dictionary<SkillType, float>();

		private static readonly Dictionary<SkillType, int> instances = new Dictionary<SkillType, int>();

		public static bool Running => startTime.HasValue;

		public static void Start()
		{
			if (Settings.ShowExperience && !startTime.HasValue)
			{
				Reset();
				startTime = DateTime.Now;
			}
		}

		public static void Reset()
		{
			startTime = null;
			endTime = null;
			experiences.Clear();
			instances.Clear();
		}

		public static void AddExperience(SkillType skill, float value = 1f)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: 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_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: 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_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			Start();
			if (startTime.HasValue)
			{
				if (!experiences.ContainsKey(skill))
				{
					experiences.Add(skill, 0f);
				}
				if (!instances.ContainsKey(skill))
				{
					instances.Add(skill, 0);
				}
				experiences[skill] += value;
				instances[skill]++;
				endTime = DateTime.Now;
			}
		}

		public static float GetExperienceModifier()
		{
			SEMan seman = ((Character)Player.m_localPlayer).m_seman;
			float result = 1f;
			seman.ModifyRaiseSkill((SkillType)999, ref result);
			return result;
		}

		private static Skill GetSkill(SkillType type)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			return Player.m_localPlayer.m_skills.GetSkill(type);
		}

		public static float GetLevel(SkillType type)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			return GetSkill(type).m_level;
		}

		public static float GetCurrent(SkillType type)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			return GetSkill(type).m_accumulator;
		}

		public static float GetTotal(SkillType type)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			return GetSkill(type).GetNextLevelRequirement();
		}

		public static List<string>? Get()
		{
			if (!Settings.ShowExperience)
			{
				return null;
			}
			double time = 1.0;
			if (startTime.HasValue && endTime.HasValue)
			{
				time = endTime.Value.Subtract(startTime.Value).TotalMilliseconds;
			}
			time /= 60000.0;
			if (time == 0.0)
			{
				time = 1.0;
			}
			List<string> list = experiences.Select(delegate(KeyValuePair<SkillType, float> kvp)
			{
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				//IL_0030: Unknown result type (might be due to invalid IL or missing references)
				//IL_0051: Unknown result type (might be due to invalid IL or missing references)
				//IL_0058: Unknown result type (might be due to invalid IL or missing references)
				//IL_007a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0089: Unknown result type (might be due to invalid IL or missing references)
				SkillType key = kvp.Key;
				float value = kvp.Value;
				string text = ((object)(SkillType)(ref key)).ToString() + " " + Format.Float(GetLevel(key), "0.##", "white") + " (" + Format.Progress(GetCurrent(key), GetTotal(key)) + "): ";
				float num = value * (float)(instances[key] - 1) / (float)instances[key];
				return text + Format.Float(kvp.Value) + " (" + Format.Float((double)num / time) + " per minute)";
			}).ToList();
			list.Insert(0, "Experience gain: " + Format.Percent(GetExperienceModifier()));
			return list;
		}
	}
	public class Settings
	{
		public static ConfigEntry<bool> configShowDPS;

		public static ConfigEntry<bool> configShowExperience;

		public static ConfigEntry<int> configSetSkills;

		public static ConfigEntry<int> configPlayerDamageRange;

		public static ConfigEntry<int> configCreatureDamageRange;

		public static ConfigEntry<int> configMaxAttackChainLevels;

		public static ConfigEntry<bool> configNoStaminaUsage;

		public static ConfigEntry<bool> configAutoFireBow;

		public static bool IsCheats
		{
			get
			{
				if (!Object.op_Implicit((Object)(object)ZNet.instance) || !ZNet.instance.IsServer())
				{
					return ((Terminal)Console.instance).IsCheatsEnabled();
				}
				return true;
			}
		}

		public static bool ShowDPS => configShowDPS.Value;

		public static bool ShowExperience => configShowExperience.Value;

		private static bool SettingsEnabled
		{
			get
			{
				if (IsCheats)
				{
					if (!ShowDPS)
					{
						return ShowExperience;
					}
					return true;
				}
				return false;
			}
		}

		public static float SetSkills
		{
			get
			{
				if (!SettingsEnabled || configSetSkills.Value == -1)
				{
					return -1f;
				}
				return FromPercent(configSetSkills.Value);
			}
		}

		public static float PlayerDamageRange
		{
			get
			{
				if (!SettingsEnabled || configPlayerDamageRange.Value == 15)
				{
					return -1f;
				}
				return FromPercent(configPlayerDamageRange.Value);
			}
		}

		public static float CreatureDamageRange
		{
			get
			{
				if (!SettingsEnabled || configCreatureDamageRange.Value == 25)
				{
					return -1f;
				}
				return FromPercent(configCreatureDamageRange.Value);
			}
		}

		public static int MaxAttackChainLevels
		{
			get
			{
				if (!SettingsEnabled || configMaxAttackChainLevels.Value == -1)
				{
					return -1;
				}
				return configMaxAttackChainLevels.Value;
			}
		}

		public static bool NoStaminaUsage
		{
			get
			{
				if (SettingsEnabled)
				{
					return configNoStaminaUsage.Value;
				}
				return false;
			}
		}

		public static bool AutoFireBow
		{
			get
			{
				if (SettingsEnabled)
				{
					return configAutoFireBow.Value;
				}
				return false;
			}
		}

		private static float FromPercent(int value)
		{
			return (float)value / 100f;
		}

		public static void Init(ConfigFile config)
		{
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Expected O, but got Unknown
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Expected O, but got Unknown
			//IL_0109: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: Expected O, but got Unknown
			//IL_0131: Unknown result type (might be due to invalid IL or missing references)
			//IL_013b: Expected O, but got Unknown
			string text = "DPS";
			configShowDPS = config.Bind<bool>(text, "Show DPS meter", false, "Show DPS meter (toggle with P button in the game)");
			configShowDPS.SettingChanged += delegate
			{
				if (!ShowDPS)
				{
					DPSMeter.Reset();
				}
			};
			configShowExperience = config.Bind<bool>(text, "Show experience meter", false, "Show experience meter (toggle with L button in the game)");
			configShowExperience.SettingChanged += delegate
			{
				if (!ShowExperience)
				{
					ExperienceMeter.Reset();
				}
			};
			configSetSkills = config.Bind<int>(text, "Override skill levels", -1, new ConfigDescription("Overrides skill level checks (-1 to disable).", (AcceptableValueBase)(object)new AcceptableValueRange<int>(-1, 100), Array.Empty<object>()));
			configPlayerDamageRange = config.Bind<int>(text, "Min/max damage range for players", 15, new ConfigDescription("Overrides player damage range (15 to disable).", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 40), Array.Empty<object>()));
			configCreatureDamageRange = config.Bind<int>(text, "Min/max damage range for creatures", 25, new ConfigDescription("Overrides creature damage range (25 to disable).", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 100), new object[1]
			{
				new ConfigurationManagerAttributes
				{
					ShowRangeAsPercent = false
				}
			}));
			configMaxAttackChainLevels = config.Bind<int>(text, "Maximum attack chain levels", -1, new ConfigDescription("Caps the attack chains for easier testing (-1 to disable).", (AcceptableValueBase)(object)new AcceptableValueRange<int>(-1, 5), Array.Empty<object>()));
			configNoStaminaUsage = config.Bind<bool>(text, "No stamina usage", false, "Set true to disable stamina usage.");
			configAutoFireBow = config.Bind<bool>(text, "Auto fire bow", false, "Automatically fires the bow when fully drawn.");
		}

		public static bool CheatsRequired()
		{
			if (!IsCheats)
			{
				if (configSetSkills.Value < 0 && configPlayerDamageRange.Value == 15 && configCreatureDamageRange.Value == 25 && configMaxAttackChainLevels.Value < 0 && !configNoStaminaUsage.Value)
				{
					return configAutoFireBow.Value;
				}
				return true;
			}
			return false;
		}
	}
}