using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Text;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Steamworks;
using UnityEngine;
using UnityEngine.SceneManagement;

[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("AnriDiagnostics")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.1.1.0")]
[assembly: AssemblyInformationalVersion("1.1.1")]
[assembly: AssemblyProduct("AnriDiagnostics")]
[assembly: AssemblyTitle("AnriDiagnostics")]
[assembly: AssemblyVersion("1.1.1.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace AnriDiagnostics
{
	[BepInPlugin("anri.diagnostics", "AnriDiagnostics", "1.1.3")]
	public class Plugin : BaseUnityPlugin
	{
		[HarmonyPatch(typeof(Terminal), "InitTerminal")]
		private static class RegisterCommands
		{
			[Serializable]
			[CompilerGenerated]
			private sealed class <>c
			{
				public static readonly <>c <>9 = new <>c();

				public static ConsoleEvent <>9__0_0;

				public static ConsoleEvent <>9__0_1;

				public static ConsoleEvent <>9__0_2;

				internal void <Postfix>b__0_0(ConsoleEventArgs args)
				{
					DumpDuplicates((args.Length > 1) ? args[1] : null);
				}

				internal void <Postfix>b__0_1(ConsoleEventArgs args)
				{
					Out(BuildStats(0, 0f, 0f));
				}

				internal void <Postfix>b__0_2(ConsoleEventArgs args)
				{
					DumpPatchOwners();
				}
			}

			private static void Postfix()
			{
				//IL_0033: 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_006c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0057: Unknown result type (might be due to invalid IL or missing references)
				//IL_005c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0062: Expected O, but got Unknown
				//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
				//IL_0090: Unknown result type (might be due to invalid IL or missing references)
				//IL_0095: Unknown result type (might be due to invalid IL or missing references)
				//IL_009b: Expected O, but got Unknown
				object obj = <>c.<>9__0_0;
				if (obj == null)
				{
					ConsoleEvent val = delegate(ConsoleEventArgs args)
					{
						DumpDuplicates((args.Length > 1) ? args[1] : null);
					};
					<>c.<>9__0_0 = val;
					obj = (object)val;
				}
				new ConsoleCommand("dupeitems", "List duplicate ObjectDB item entries (optional filter text)", (ConsoleEvent)obj, false, false, false, false, false, false, (ConsoleOptionsFetcher)null, false, false, false);
				object obj2 = <>c.<>9__0_1;
				if (obj2 == null)
				{
					ConsoleEvent val2 = delegate
					{
						Out(BuildStats(0, 0f, 0f));
					};
					<>c.<>9__0_1 = val2;
					obj2 = (object)val2;
				}
				new ConsoleCommand("serverstats", "Print ZDO count, players and connection quality", (ConsoleEvent)obj2, false, false, false, false, false, false, (ConsoleOptionsFetcher)null, false, false, false);
				object obj3 = <>c.<>9__0_2;
				if (obj3 == null)
				{
					ConsoleEvent val3 = delegate
					{
						DumpPatchOwners();
					};
					<>c.<>9__0_2 = val3;
					obj3 = (object)val3;
				}
				new ConsoleCommand("patchowners", "List Harmony patch owners on ObjectDB/ZNetScene setup", (ConsoleEvent)obj3, false, false, false, false, false, false, (ConsoleOptionsFetcher)null, false, false, false);
			}
		}

		public const string GUID = "anri.diagnostics";

		public const string NAME = "AnriDiagnostics";

		public const string VERSION = "1.1.3";

		internal static ManualLogSource Log;

		internal static ConfigEntry<int> StatsInterval;

		private float _frameMax;

		private float _frameSum;

		private int _frames;

		private float _nextStats;

		private static readonly FieldRef<ZSteamSocket, HSteamNetConnection> SteamCon = AccessTools.FieldRefAccess<ZSteamSocket, HSteamNetConnection>("m_con");

		private static readonly Dictionary<Type, FieldInfo> InnerSocketFields = new Dictionary<Type, FieldInfo>();

		private void Awake()
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			Log = ((BaseUnityPlugin)this).Logger;
			StatsInterval = ((BaseUnityPlugin)this).Config.Bind<int>("ServerStats", "IntervalSeconds", 60, "On a dedicated server, log world/network statistics every N seconds (ZDO count, players, per-peer ping and bandwidth, server tick times). 0 disables.");
			new Harmony("anri.diagnostics").PatchAll(typeof(Plugin).Assembly);
			Log.LogInfo((object)"AnriDiagnostics 1.1.3 loaded. Console: dupeitems, patchowners, serverstats");
		}

		private void Update()
		{
			float unscaledDeltaTime = Time.unscaledDeltaTime;
			_frames++;
			_frameSum += unscaledDeltaTime;
			if (unscaledDeltaTime > _frameMax)
			{
				_frameMax = unscaledDeltaTime;
			}
			if (StatsInterval.Value > 0 && !((Object)(object)ZNet.instance == (Object)null) && ZNet.instance.IsServer() && ZNet.instance.IsDedicated() && !(Time.unscaledTime < _nextStats))
			{
				_nextStats = Time.unscaledTime + (float)StatsInterval.Value;
				try
				{
					Log.LogInfo((object)BuildStats(_frames, _frameSum, _frameMax));
				}
				catch (Exception ex)
				{
					Log.LogWarning((object)("stats failed: " + ex.Message));
				}
				_frames = 0;
				_frameSum = 0f;
				_frameMax = 0f;
			}
		}

		internal static string BuildStats(int frames, float frameSum, float frameMax)
		{
			StringBuilder stringBuilder = new StringBuilder();
			ZDOMan instance = ZDOMan.instance;
			ZNet instance2 = ZNet.instance;
			stringBuilder.Append("[Stats] ");
			if (instance != null)
			{
				stringBuilder.Append($"ZDOs={instance.NrOfObjects()} sentZDO/s={instance.GetSentZDOs()} recvZDO/s={instance.GetRecvZDOs()} ");
			}
			if ((Object)(object)instance2 != (Object)null)
			{
				stringBuilder.Append($"players={instance2.GetNrOfPlayers()} ");
				if (frames > 0)
				{
					stringBuilder.Append($"tick avg={frameSum / (float)frames * 1000f:0.0}ms max={frameMax * 1000f:0}ms ");
				}
				foreach (ZNetPeer peer in instance2.GetPeers())
				{
					if (peer == null || peer.m_socket == null)
					{
						continue;
					}
					try
					{
						ConnectionQuality(peer.m_socket, out var lq, out var rq, out var ping, out var outB, out var inB);
						stringBuilder.Append($"| {peer.m_playerName}: ping={ping}ms out={outB / 1024f:0.0}KB/s in={inB / 1024f:0.0}KB/s q={lq:0.00}/{rq:0.00} queue={peer.m_socket.GetSendQueueSize()} ");
					}
					catch (Exception ex)
					{
						string name = ((object)peer.m_socket).GetType().Name;
						string name2 = ex.GetType().Name;
						string text = ex.Message.Replace("\r\n", " ").Replace('\r', ' ').Replace('\n', ' ');
						string text2 = "unknown";
						try
						{
							MethodBase methodBase = new StackTrace(ex).GetFrame(0)?.GetMethod();
							if (methodBase != null)
							{
								text2 = methodBase.DeclaringType?.Name + "." + methodBase.Name;
							}
						}
						catch
						{
						}
						stringBuilder.Append("| " + peer.m_playerName + ": quality n/a (socket=" + name + "; " + name2 + ": " + text + "; at " + text2 + ") ");
					}
				}
			}
			return stringBuilder.ToString();
		}

		private static ZSteamSocket FindSteamSocket(ISocket socket)
		{
			int num = 0;
			while (num < 8 && socket != null)
			{
				ZSteamSocket val = (ZSteamSocket)(object)((socket is ZSteamSocket) ? socket : null);
				if (val != null)
				{
					return val;
				}
				Type type = ((object)socket).GetType();
				if (!InnerSocketFields.TryGetValue(type, out var value))
				{
					Type type2 = type;
					while (type2 != null && value == null)
					{
						foreach (FieldInfo declaredField in AccessTools.GetDeclaredFields(type2))
						{
							if (!declaredField.IsStatic)
							{
								object? value2 = declaredField.GetValue(socket);
								ISocket val2 = (ISocket)((value2 is ISocket) ? value2 : null);
								if (val2 != null && val2 != socket)
								{
									value = declaredField;
									break;
								}
							}
						}
						type2 = type2.BaseType;
					}
					InnerSocketFields[type] = value;
				}
				if (!(value == null))
				{
					object? value3 = value.GetValue(socket);
					ISocket val3 = (ISocket)((value3 is ISocket) ? value3 : null);
					if (val3 != null && val3 != socket)
					{
						socket = val3;
						num++;
						continue;
					}
				}
				return null;
			}
			return null;
		}

		internal static void ConnectionQuality(ISocket socket, out float lq, out float rq, out int ping, out float outB, out float inB)
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Invalid comparison between Unknown and I4
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			ZSteamSocket val = FindSteamSocket(socket);
			if (val != null && (Object)(object)ZNet.instance != (Object)null && ZNet.instance.IsDedicated())
			{
				SteamNetConnectionRealTimeStatus_t val2 = default(SteamNetConnectionRealTimeStatus_t);
				SteamNetConnectionRealTimeLaneStatus_t val3 = default(SteamNetConnectionRealTimeLaneStatus_t);
				if ((int)SteamGameServerNetworkingSockets.GetConnectionRealTimeStatus(SteamCon.Invoke(val), ref val2, 0, ref val3) == 1)
				{
					lq = val2.m_flConnectionQualityLocal;
					rq = val2.m_flConnectionQualityRemote;
					ping = val2.m_nPing;
					outB = val2.m_flOutBytesPerSec;
					inB = val2.m_flInBytesPerSec;
				}
				else
				{
					lq = (rq = 0f);
					ping = 0;
					outB = (inB = 0f);
				}
			}
			else
			{
				socket.GetConnectionQuality(ref lq, ref rq, ref ping, ref outB, ref inB);
			}
		}

		internal static void Out(string s)
		{
			Log.LogInfo((object)s);
			if ((Object)(object)Console.instance != (Object)null)
			{
				Console.instance.Print(s);
			}
		}

		private static void DumpDuplicates(string filter)
		{
			//IL_027a: Unknown result type (might be due to invalid IL or missing references)
			//IL_027f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0293: Unknown result type (might be due to invalid IL or missing references)
			//IL_0298: Unknown result type (might be due to invalid IL or missing references)
			//IL_0312: Unknown result type (might be due to invalid IL or missing references)
			ObjectDB instance = ObjectDB.instance;
			if ((Object)(object)instance == (Object)null)
			{
				Out("ObjectDB not ready.");
				return;
			}
			Dictionary<string, List<GameObject>> dictionary = new Dictionary<string, List<GameObject>>();
			ItemDrop val = default(ItemDrop);
			foreach (GameObject item in instance.m_items)
			{
				if ((Object)(object)item == (Object)null)
				{
					Out("  <null entry in ObjectDB.m_items>");
				}
				else
				{
					if (!item.TryGetComponent<ItemDrop>(ref val) || val.m_itemData?.m_shared == null)
					{
						continue;
					}
					string name = val.m_itemData.m_shared.m_name;
					if (filter == null || name.IndexOf(filter, StringComparison.OrdinalIgnoreCase) >= 0 || ((Object)item).name.IndexOf(filter, StringComparison.OrdinalIgnoreCase) >= 0)
					{
						if (!dictionary.TryGetValue(name, out var value))
						{
							value = (dictionary[name] = new List<GameObject>());
						}
						value.Add(item);
					}
				}
			}
			int num = 0;
			Out($"ObjectDB.m_items count: {instance.m_items.Count}");
			foreach (KeyValuePair<string, List<GameObject>> item2 in from g in dictionary
				where g.Value.Count > 1
				orderby g.Key
				select g)
			{
				num++;
				Out($"== {item2.Key} x{item2.Value.Count}");
				foreach (GameObject item3 in item2.Value)
				{
					SharedData shared = item3.GetComponent<ItemDrop>().m_itemData.m_shared;
					int stableHashCode = StringExtensionMethods.GetStableHashCode(((Object)item3).name);
					Dictionary<int, GameObject> value2 = Traverse.Create((object)instance).Field("m_itemByHash").GetValue<Dictionary<int, GameObject>>();
					GameObject value3;
					bool flag = value2 != null && value2.TryGetValue(stableHashCode, out value3) && (Object)(object)value3 == (Object)(object)item3;
					Dictionary<int, GameObject> dictionary2 = (((Object)(object)ZNetScene.instance != (Object)null) ? Traverse.Create((object)ZNetScene.instance).Field("m_namedPrefabs").GetValue<Dictionary<int, GameObject>>() : null);
					GameObject value4;
					bool flag2 = dictionary2 != null && dictionary2.TryGetValue(stableHashCode, out value4) && (Object)(object)value4 == (Object)(object)item3;
					string text = (((Object)(object)item3.transform.parent != (Object)null) ? ((Object)item3.transform.parent).name : "-");
					Scene scene = item3.scene;
					object obj;
					if (!((Scene)(ref scene)).IsValid())
					{
						obj = "(asset)";
					}
					else
					{
						scene = item3.scene;
						obj = ((Scene)(ref scene)).name;
					}
					string text2 = (string)obj;
					Out($"   prefab='{((Object)item3).name}' id={((Object)item3).GetInstanceID()} set='{shared.m_setName}' sharedId={((object)shared).GetHashCode()} " + $"byHash={flag} znet={flag2} parent={text} scene={text2} hideFlags={((Object)item3).hideFlags} " + "dropPrefab=" + (((Object)(object)item3.GetComponent<ItemDrop>().m_itemData.m_dropPrefab != (Object)null) ? ((Object)item3.GetComponent<ItemDrop>().m_itemData.m_dropPrefab).name : "null"));
				}
			}
			Out($"{num} duplicated display name(s).");
		}

		private static void DumpPatchOwners()
		{
			(Type, string)[] array = new(Type, string)[9]
			{
				(typeof(ObjectDB), "Awake"),
				(typeof(ObjectDB), "CopyOtherDB"),
				(typeof(ObjectDB), "UpdateRegisters"),
				(typeof(ZNetScene), "Awake"),
				(typeof(FejdStartup), "Awake"),
				(typeof(FejdStartup), "SetupObjectDB"),
				(typeof(Game), "Start"),
				(typeof(ItemDrop), "Awake"),
				(typeof(ItemDrop), "Start")
			};
			for (int i = 0; i < array.Length; i++)
			{
				(Type, string) tuple = array[i];
				Type item = tuple.Item1;
				string item2 = tuple.Item2;
				MethodInfo methodInfo = AccessTools.Method(item, item2, (Type[])null, (Type[])null);
				if (methodInfo == null)
				{
					Out(item.Name + "." + item2 + ": not found");
					continue;
				}
				Patches patchInfo = Harmony.GetPatchInfo((MethodBase)methodInfo);
				if (patchInfo == null)
				{
					Out(item.Name + "." + item2 + ": no patches");
					continue;
				}
				Out(item.Name + "." + item2 + ": prefix[" + Fmt(patchInfo.Prefixes) + "] postfix[" + Fmt(patchInfo.Postfixes) + "] transpiler[" + Fmt(patchInfo.Transpilers) + "]");
			}
			static string Fmt(IEnumerable<Patch> ps)
			{
				return string.Join(", ", ps.Select((Patch p) => p.owner + ":" + p.PatchMethod.DeclaringType?.Name + "." + p.PatchMethod.Name));
			}
		}
	}
}

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 BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using UnityEngine;

[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("BossKillScaling")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("BossKillScaling")]
[assembly: AssemblyTitle("BossKillScaling")]
[assembly: AssemblyVersion("1.0.0.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace BossKillScaling
{
	[BepInPlugin("anri.bosskillscaling", "BossKillScaling", "1.5.0")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class Plugin : BaseUnityPlugin
	{
		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static Func<KeyValuePair<string, int>, bool> <>9__33_0;

			public static Func<string, string> <>9__42_0;

			public static Func<string, string> <>9__42_1;

			public static Func<string, string> <>9__44_0;

			public static Func<string, string> <>9__44_1;

			public static Func<string, bool> <>9__45_1;

			public static Func<string, string> <>9__45_2;

			public static ConsoleEvent <>9__45_0;

			internal bool <ProgressCap>b__33_0(KeyValuePair<string, int> e)
			{
				return e.Key.Equals("none", StringComparison.OrdinalIgnoreCase);
			}

			internal string <BeforeGenerateDropList>b__42_0(string e)
			{
				return e.Trim();
			}

			internal string <BeforeGenerateDropList>b__42_1(string e)
			{
				return e.Trim();
			}

			internal string <AfterGenerateDropList>b__44_0(string e)
			{
				return e.Trim();
			}

			internal string <AfterGenerateDropList>b__44_1(string e)
			{
				return e.Trim();
			}

			internal void <RegisterCommand>b__45_0(ConsoleEventArgs args)
			{
				double result;
				int result2;
				if ((Object)(object)ZoneSystem.instance == (Object)null)
				{
					args.Context.AddString("No world loaded.");
				}
				else if (args.Args.Length == 1)
				{
					foreach (string item in from k in ZoneSystem.instance.GetGlobalKeys()
						where k.StartsWith("anri_bosskills_", StringComparison.OrdinalIgnoreCase)
						orderby k
						select k)
					{
						args.Context.AddString(item);
					}
					string key;
					int num = ProgressCap(out key);
					args.Context.AddString($"Progress cap: {num} stars ({key}).");
				}
				else if (args.Args.Length == 4 && args.Args[1].Equals("preview", StringComparison.OrdinalIgnoreCase) && double.TryParse(args.Args[3], NumberStyles.Float, CultureInfo.InvariantCulture, out result) && result >= 0.0 && !double.IsInfinity(result))
				{
					args.Context.AddString($"{Prefab(args.Args[2])}: kills={Count(args.Args[2])}, distance={result.ToString(CultureInfo.InvariantCulture)}m, next spawn={Stars(args.Args[2], result)} stars.");
				}
				else if (args.Args.Length == 3 && int.TryParse(args.Args[2], NumberStyles.Integer, CultureInfo.InvariantCulture, out result2) && result2 >= 0)
				{
					ZoneSystem.instance.SetGlobalKey("anri_bosskills_" + Prefab(args.Args[1]) + " " + result2.ToString(CultureInfo.InvariantCulture));
					args.Context.AddString($"Requested {Prefab(args.Args[1])} counter = {result2}.");
				}
				else
				{
					args.Context.AddString("Usage: bosskills | bosskills <prefab> <n> | bosskills preview <prefab> <distance>");
				}
			}

			internal bool <RegisterCommand>b__45_1(string k)
			{
				return k.StartsWith("anri_bosskills_", StringComparison.OrdinalIgnoreCase);
			}

			internal string <RegisterCommand>b__45_2(string k)
			{
				return k;
			}
		}

		public const string GUID = "anri.bosskillscaling";

		public const string NAME = "BossKillScaling";

		public const string VERSION = "1.5.0";

		private const string SLS_GUID = "MidnightsFX.StarLevelSystem";

		private const string CounterPrefix = "anri_bosskills_";

		private const string DefaultRings = "0:0,750:1,1200:2,2000:3,3000:4,4000:5,5000:6,6000:7,7000:8,8000:9,9100:10";

		private const string DefaultProgress = "none:1,defeated_eikthyr:2,defeated_gdking:4,defeated_bonemass:5,defeated_dragon:6,defeated_goblinking:8,defeated_queen:9,defeated_fader:10,defeated_frozenking_p3:20";

		internal static ManualLogSource Log;

		private static readonly Dictionary<int, string> BossPrefabs = new Dictionary<int, string>();

		private static bool ZdoDestroyWarningLogged;

		private static bool DropChanceWarningLogged;

		private static readonly FieldRef<CharacterDrop, Character> DropCharacter = AccessTools.FieldRefAccess<CharacterDrop, Character>("m_character");

		private static ConfigEntry<bool> CapBossEquipment;

		private static ConfigEntry<int> BossEquipmentMaxCount;

		private static ConfigEntry<float> BossEquipmentChanceMultiplier;

		private static ConfigEntry<string> BossEquipmentExtraPrefabs;

		private static ConfigEntry<string> BossEquipmentIgnorePrefabs;

		private static ConfigEntry<bool> Enabled;

		private static ConfigEntry<string> LadderMode;

		private static ConfigEntry<bool> CountCappedKills;

		private static ConfigEntry<bool> ApplyProgressCapToAllCreatures;

		private static ConfigEntry<int> MaxStars;

		private static ConfigEntry<bool> Verbose;

		private static volatile SortedDictionary<double, int> Rings = new SortedDictionary<double, int>();

		private static volatile List<KeyValuePair<string, int>> Progress = new List<KeyValuePair<string, int>>();

		private void Awake()
		{
			//IL_02c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ca: Expected O, but got Unknown
			//IL_04b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_04c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_04d5: Expected O, but got Unknown
			//IL_04d5: Expected O, but got Unknown
			//IL_0505: Unknown result type (might be due to invalid IL or missing references)
			//IL_0512: Expected O, but got Unknown
			//IL_053a: Unknown result type (might be due to invalid IL or missing references)
			//IL_054f: Unknown result type (might be due to invalid IL or missing references)
			//IL_055c: Expected O, but got Unknown
			//IL_055c: Expected O, but got Unknown
			//IL_0585: Unknown result type (might be due to invalid IL or missing references)
			//IL_058a: Unknown result type (might be due to invalid IL or missing references)
			//IL_059d: Expected O, but got Unknown
			//IL_05c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_05d3: Expected O, but got Unknown
			//IL_05fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0609: Expected O, but got Unknown
			Log = ((BaseUnityPlugin)this).Logger;
			Enabled = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "Enabled", true, AdminOnly("Master switch for the deterministic boss star ladder and its caps. Off = StarLevelSystem's own rolls."));
			LadderMode = ((BaseUnityPlugin)this).Config.Bind<string>("General", "LadderMode", "Sqrt", AdminOnly("Sqrt = star n costs ceil(sqrt(n)) kills, cumulative: 1,3,5,7,10,13,16,19,22,26 total kills for stars 1-10. Blocks = the original ladder in blocks of nine kills (0,1,1,2,2,2,2,2,3 then +3 per block).", (AcceptableValueBase)(object)new AcceptableValueList<string>(new string[2] { "Sqrt", "Blocks" })));
			CountCappedKills = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "CountCappedKills", true, AdminOnly("Every boss kill advances the counter, even when a distance or progress cap lowered that fight's stars. Off = only fights that spawned at the full ladder value count."));
			ApplyProgressCapToAllCreatures = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "ApplyProgressCapToAllCreatures", true, AdminOnly("Also clip every creature's star level to the boss-progress cap through StarLevelSystem's GetMaxCreatureLevel. Off = bosses only."));
			ConfigEntry<string> rings = ((BaseUnityPlugin)this).Config.Bind<string>("General", "RingMaxStars", "0:0,750:1,1200:2,2000:3,3000:4,4000:5,5000:6,6000:7,7000:8,8000:9,9100:10", AdminOnly("Distance in metres:max stars pairs. Reparsed when changed."));
			ConfigEntry<string> progress = ((BaseUnityPlugin)this).Config.Bind<string>("General", "ProgressCaps", "none:1,defeated_eikthyr:2,defeated_gdking:4,defeated_bonemass:5,defeated_dragon:6,defeated_goblinking:8,defeated_queen:9,defeated_fader:10,defeated_frozenking_p3:20", AdminOnly("Ordered global key:max stars ladder; last present key wins. Reparsed when changed."));
			MaxStars = ((BaseUnityPlugin)this).Config.Bind<int>("General", "MaxStars", 10, AdminOnly("Absolute boss star ceiling.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 2147483646)));
			Verbose = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "Verbose", false, "Log boss level selection, counted/skipped boss deaths, capped boss equipment drops, and equipment drop chance adjustments.");
			CapBossEquipment = ((BaseUnityPlugin)this).Config.Bind<bool>("BossDrops", "CapBossEquipment", true, AdminOnly("Cap equipment drops per boss kill."));
			BossEquipmentMaxCount = ((BaseUnityPlugin)this).Config.Bind<int>("BossDrops", "BossEquipmentMaxCount", 1, AdminOnly("Maximum total copies of each equipment prefab per boss kill.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, int.MaxValue)));
			BossEquipmentChanceMultiplier = ((BaseUnityPlugin)this).Config.Bind<float>("BossDrops", "BossEquipmentChanceMultiplier", 2f, AdminOnly("Multiplies the base drop chance of equipment drops from bosses before the vanilla star multiplier. 1 = unchanged.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 100f)));
			BossEquipmentExtraPrefabs = ((BaseUnityPlugin)this).Config.Bind<string>("BossDrops", "BossEquipmentExtraPrefabs", "", AdminOnly("Comma-separated prefab names to cap regardless of item type."));
			BossEquipmentIgnorePrefabs = ((BaseUnityPlugin)this).Config.Bind<string>("BossDrops", "BossEquipmentIgnorePrefabs", "", AdminOnly("Comma-separated prefab names never capped; overrides extra prefabs."));
			rings.SettingChanged += delegate
			{
				ParseRings(rings.Value);
			};
			progress.SettingChanged += delegate
			{
				ParseProgress(progress.Value);
			};
			ParseRings(rings.Value);
			ParseProgress(progress.Value);
			if (!Chainloader.PluginInfos.ContainsKey("MidnightsFX.StarLevelSystem"))
			{
				Log.LogInfo((object)"BossKillScaling idle: StarLevelSystem not loaded.");
				return;
			}
			Harmony val = new Harmony("anri.bosskillscaling");
			Assembly slsAssembly = ((object)Chainloader.PluginInfos["MidnightsFX.StarLevelSystem"].Instance).GetType().Assembly;
			Type type = FindType("LevelSelection");
			Type type2 = FindType("DataObjects");
			Type type3 = type2?.GetNestedType("CreatureSpecificSetting");
			Type type4 = type2?.GetNestedType("BiomeSpecificSetting");
			if (type == null || type3 == null || type4 == null)
			{
				Log.LogWarning((object)$"SLS types not found (LevelSelection={type != null}, DataObjects={type2 != null}, Creature={type3 != null}, Biome={type4 != null}).");
			}
			MethodInfo methodInfo = ((type == null || type3 == null || type4 == null) ? null : AccessTools.Method(type, "DetermineLevel", new Type[7]
			{
				typeof(Character),
				typeof(ZDO),
				type3,
				type4,
				typeof(Biome),
				typeof(int),
				typeof(bool)
			}, (Type[])null));
			MethodInfo methodInfo2 = ((type == null || type3 == null || type4 == null) ? null : AccessTools.Method(type, "GetMaxCreatureLevel", new Type[5]
			{
				typeof(Character),
				type3,
				type4,
				typeof(Biome),
				typeof(bool?)
			}, (Type[])null));
			if (methodInfo == null)
			{
				Log.LogWarning((object)"SLS LevelSelection.DetermineLevel signature missing; boss override disabled.");
			}
			else
			{
				val.Patch((MethodBase)methodInfo, new HarmonyMethod(typeof(Plugin), "BeforeDetermine", (Type[])null), new HarmonyMethod(typeof(Plugin), "AfterDetermine", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			}
			if (methodInfo2 == null)
			{
				Log.LogWarning((object)"SLS LevelSelection.GetMaxCreatureLevel signature missing; progress cap disabled.");
			}
			else
			{
				val.Patch((MethodBase)methodInfo2, (HarmonyMethod)null, new HarmonyMethod(typeof(Plugin), "AfterMaximum", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			}
			val.Patch((MethodBase)AccessTools.Method(typeof(CharacterDrop), "GenerateDropList", (Type[])null, (Type[])null), new HarmonyMethod(typeof(Plugin), "BeforeGenerateDropList", (Type[])null), new HarmonyMethod(typeof(Plugin), "RestoreDropChances", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.Method(typeof(CharacterDrop), "GenerateDropList", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(typeof(Plugin), "AfterGenerateDropList", (Type[])null)
			{
				priority = 200
			}, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.Method(typeof(ZDOMan), "HandleDestroyedZDO", (Type[])null, (Type[])null), new HarmonyMethod(typeof(Plugin), "BeforeZdoDestroyed", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val.Patch((MethodBase)AccessTools.Method(typeof(Terminal), "InitTerminal", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(typeof(Plugin), "RegisterCommand", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			Log.LogInfo((object)string.Format("{0} {1} active with StarLevelSystem {2}.", "BossKillScaling", "1.5.0", Chainloader.PluginInfos["MidnightsFX.StarLevelSystem"].Metadata.Version));
			Type FindType(string name)
			{
				try
				{
					return slsAssembly.GetTypes().FirstOrDefault((Type t) => t.Name == name);
				}
				catch (ReflectionTypeLoadException ex)
				{
					return ex.Types.FirstOrDefault((Type t) => t != null && t.Name == name);
				}
			}
		}

		private static ConfigDescription AdminOnly(string description, AcceptableValueBase range = null)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Expected O, but got Unknown
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Expected O, but got Unknown
			return new ConfigDescription(description, range, new object[1] { (object)new ConfigurationManagerAttributes
			{
				IsAdminOnly = true
			} });
		}

		private static void ParseRings(string text)
		{
			SortedDictionary<double, int> sortedDictionary = new SortedDictionary<double, int>();
			string[] array = text.Split(new char[1] { ',' });
			foreach (string text2 in array)
			{
				string[] array2 = text2.Split(new char[1] { ':' });
				if (array2.Length == 2 && double.TryParse(array2[0], NumberStyles.Float, CultureInfo.InvariantCulture, out var result) && !double.IsNaN(result) && !double.IsInfinity(result) && result >= 0.0 && TryCap(array2[1], out var cap))
				{
					sortedDictionary[result] = cap;
				}
				else
				{
					Log.LogWarning((object)("Ignoring invalid RingMaxStars entry '" + text2 + "'."));
				}
			}
			if (!sortedDictionary.ContainsKey(0.0))
			{
				sortedDictionary[0.0] = 0;
			}
			Rings = sortedDictionary;
		}

		private static void ParseProgress(string text)
		{
			List<KeyValuePair<string, int>> list = new List<KeyValuePair<string, int>>();
			string[] array = text.Split(new char[1] { ',' });
			foreach (string text2 in array)
			{
				string[] array2 = text2.Split(new char[1] { ':' });
				if (array2.Length == 2 && !string.IsNullOrWhiteSpace(array2[0]) && TryCap(array2[1], out var cap))
				{
					list.Add(new KeyValuePair<string, int>(array2[0].Trim(), cap));
				}
				else
				{
					Log.LogWarning((object)("Ignoring invalid ProgressCaps entry '" + text2 + "'."));
				}
			}
			Progress = list;
		}

		private static bool TryCap(string text, out int cap)
		{
			if (int.TryParse(text, NumberStyles.Integer, CultureInfo.InvariantCulture, out cap) && cap >= 0)
			{
				return cap < int.MaxValue;
			}
			return false;
		}

		private static string Prefab(string name)
		{
			return name.Replace("(Clone)", "").Trim();
		}

		private static int Count(string prefab)
		{
			string s = default(string);
			if ((Object)(object)ZoneSystem.instance != (Object)null && ZoneSystem.instance.GetGlobalKey("anri_bosskills_" + Prefab(prefab), ref s) && int.TryParse(s, NumberStyles.Integer, CultureInfo.InvariantCulture, out var result))
			{
				return Math.Max(0, result);
			}
			return 0;
		}

		private static int Formula(int k)
		{
			if (LadderMode.Value == "Blocks")
			{
				int num = k % 9 + 1;
				return 3 * (k / 9) + ((num != 1) ? ((int)Math.Floor(Math.Sqrt(num))) : 0);
			}
			int num2 = 0;
			int result = 0;
			for (int i = 1; i <= 1000; i++)
			{
				num2 += (int)Math.Ceiling(Math.Sqrt(i));
				if (num2 > k)
				{
					break;
				}
				result = i;
			}
			return result;
		}

		private static int ProgressCap(out string key)
		{
			int result = 1;
			key = "none";
			List<KeyValuePair<string, int>> progress = Progress;
			foreach (KeyValuePair<string, int> item in progress.Where((KeyValuePair<string, int> e) => e.Key.Equals("none", StringComparison.OrdinalIgnoreCase)))
			{
				result = item.Value;
			}
			foreach (KeyValuePair<string, int> item2 in progress)
			{
				if (!item2.Key.Equals("none", StringComparison.OrdinalIgnoreCase) && (Object)(object)ZoneSystem.instance != (Object)null && ZoneSystem.instance.GetGlobalKey(item2.Key))
				{
					result = item2.Value;
					key = item2.Key;
				}
			}
			return result;
		}

		private static int RingCap(double distance)
		{
			int result = 0;
			foreach (KeyValuePair<double, int> ring in Rings)
			{
				if (ring.Key > distance)
				{
					break;
				}
				result = ring.Value;
			}
			return result;
		}

		private static int Stars(string prefab, double distance)
		{
			string key;
			return Math.Min(Formula(Count(prefab)), Math.Min(RingCap(distance), Math.Min(ProgressCap(out key), MaxStars.Value)));
		}

		private static void BeforeDetermine(ZDO __1, out bool __state)
		{
			__state = __1 != null && __1.GetInt(ZDOVars.s_level, 0) > 0;
		}

		private static void AfterDetermine(Character __0, ZDO __1, int __5, bool __6, bool __state, ref int __result)
		{
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: 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)
			if (!(!Enabled.Value || (Object)(object)__0 == (Object)null || __1 == null || __state) && __0.IsBoss() && !__0.IsTamed() && __6 && __5 == 0)
			{
				Vector3 position = ((Component)__0).transform.position;
				string text = Prefab(((Object)((Component)__0).gameObject).name);
				__result = 1 + Stars(text, Math.Sqrt((double)position.x * (double)position.x + (double)position.z * (double)position.z));
				if (Verbose.Value)
				{
					Log.LogInfo((object)$"{text}: kills={Count(text)}, next spawn stars={__result - 1}.");
				}
			}
		}

		private static void AfterMaximum(ref int __result)
		{
			if (Enabled.Value && ApplyProgressCapToAllCreatures.Value)
			{
				__result = Math.Min(__result, ProgressCap(out var _) + 1);
			}
		}

		private static void BeforeZdoDestroyed(ZDOID uid)
		{
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if ((Object)(object)ZNet.instance == (Object)null || !ZNet.instance.IsServer() || (Object)(object)ZoneSystem.instance == (Object)null || (Object)(object)ZNetScene.instance == (Object)null || ZDOMan.instance == null)
				{
					return;
				}
				ZDO zDO = ZDOMan.instance.GetZDO(uid);
				if (zDO == null)
				{
					return;
				}
				int prefab = zDO.GetPrefab();
				if (!BossPrefabs.TryGetValue(prefab, out var value))
				{
					GameObject prefab2 = ZNetScene.instance.GetPrefab(prefab);
					Character val = (((Object)(object)prefab2 == (Object)null) ? null : prefab2.GetComponent<Character>());
					value = (((Object)(object)val != (Object)null && val.m_boss) ? Prefab(((Object)prefab2).name) : null);
					BossPrefabs[prefab] = value;
				}
				if (value != null && !zDO.GetBool(ZDOVars.s_tamed, false))
				{
					int num = Math.Max(0, zDO.GetInt(ZDOVars.s_level, 1) - 1);
					int num2 = Count(value);
					int num3 = Formula(num2);
					bool flag = (CountCappedKills.Value || num >= num3) && num2 < int.MaxValue;
					if (flag)
					{
						ZoneSystem.instance.SetGlobalKey("anri_bosskills_" + value + " " + (num2 + 1).ToString(CultureInfo.InvariantCulture));
					}
					if (Verbose.Value)
					{
						Log.LogInfo((object)($"{value} destroyed on server: stars={num}, uncapped requirement={num3}, counter={num2}; " + (flag ? (((num < num3) ? "counted (capped fight); " : "counted; ") + $"increment requested to {num2 + 1}.") : "skipped (clipped or counter full).")));
					}
				}
			}
			catch (Exception ex)
			{
				if (!ZdoDestroyWarningLogged)
				{
					ZdoDestroyWarningLogged = true;
					Log.LogWarning((object)("Server boss kill counting failed: " + ex.Message));
				}
			}
		}

		private static bool Equipment(ItemType type)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Expected I4, but got Unknown
			switch (type - 3)
			{
			case 0:
			case 1:
			case 2:
			case 3:
			case 4:
			case 8:
			case 11:
			case 12:
			case 14:
			case 15:
			case 16:
			case 17:
			case 19:
				return true;
			default:
				return false;
			}
		}

		private static bool CappedPrefab(GameObject prefab, HashSet<string> extra, HashSet<string> ignore)
		{
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			ItemDrop val = (((Object)(object)prefab == (Object)null) ? null : prefab.GetComponent<ItemDrop>());
			string item = (((Object)(object)prefab == (Object)null) ? "" : Prefab(((Object)prefab).name));
			if ((Object)(object)val != (Object)null && !ignore.Contains(item))
			{
				if (!extra.Contains(item))
				{
					return Equipment(val.m_itemData.m_shared.m_itemType);
				}
				return true;
			}
			return false;
		}

		private static void BeforeGenerateDropList(CharacterDrop __instance, out List<KeyValuePair<Drop, float>> __state)
		{
			__state = null;
			try
			{
				float value = BossEquipmentChanceMultiplier.Value;
				if (!CapBossEquipment.Value || value == 1f)
				{
					return;
				}
				Character val = DropCharacter.Invoke(__instance);
				if ((Object)(object)val == (Object)null || !val.IsBoss() || __instance.m_drops == null)
				{
					return;
				}
				HashSet<string> extra = new HashSet<string>(from e in BossEquipmentExtraPrefabs.Value.Split(new char[1] { ',' })
					select e.Trim(), StringComparer.Ordinal);
				HashSet<string> ignore = new HashSet<string>(from e in BossEquipmentIgnorePrefabs.Value.Split(new char[1] { ',' })
					select e.Trim(), StringComparer.Ordinal);
				__state = new List<KeyValuePair<Drop, float>>();
				foreach (Drop drop in __instance.m_drops)
				{
					if (CappedPrefab(drop.m_prefab, extra, ignore))
					{
						__state.Add(new KeyValuePair<Drop, float>(drop, drop.m_chance));
					}
				}
				foreach (KeyValuePair<Drop, float> item in __state)
				{
					item.Key.m_chance = Mathf.Clamp01(item.Value * value);
				}
				if (!Verbose.Value)
				{
					return;
				}
				foreach (KeyValuePair<Drop, float> item2 in __state)
				{
					Log.LogInfo((object)$"{Prefab(((Object)((Component)val).gameObject).name)} equipment drop chance {Prefab(((Object)item2.Key.m_prefab).name)}: {item2.Value} -> {item2.Key.m_chance}.");
				}
			}
			catch (Exception ex)
			{
				RestoreDropChances(__state);
				__state = null;
				if (!DropChanceWarningLogged)
				{
					DropChanceWarningLogged = true;
					Log.LogWarning((object)("Boss equipment drop chance adjustment failed: " + ex.Message));
				}
			}
		}

		private static void RestoreDropChances(List<KeyValuePair<Drop, float>> __state)
		{
			if (__state == null)
			{
				return;
			}
			foreach (KeyValuePair<Drop, float> item in __state)
			{
				item.Key.m_chance = item.Value;
			}
		}

		private static void AfterGenerateDropList(CharacterDrop __instance, List<KeyValuePair<GameObject, int>> __result)
		{
			Character val = DropCharacter.Invoke(__instance);
			if (!CapBossEquipment.Value || (Object)(object)val == (Object)null || !val.IsBoss() || __result == null)
			{
				return;
			}
			HashSet<string> extra = new HashSet<string>(from e in BossEquipmentExtraPrefabs.Value.Split(new char[1] { ',' })
				select e.Trim(), StringComparer.Ordinal);
			HashSet<string> ignore = new HashSet<string>(from e in BossEquipmentIgnorePrefabs.Value.Split(new char[1] { ',' })
				select e.Trim(), StringComparer.Ordinal);
			Dictionary<string, int> dictionary = new Dictionary<string, int>(StringComparer.Ordinal);
			Dictionary<string, long> dictionary2 = new Dictionary<string, long>(StringComparer.Ordinal);
			List<KeyValuePair<GameObject, int>> list = new List<KeyValuePair<GameObject, int>>();
			int num = Math.Max(0, BossEquipmentMaxCount.Value);
			foreach (KeyValuePair<GameObject, int> item in __result)
			{
				string key = (((Object)(object)item.Key == (Object)null) ? "" : Prefab(((Object)item.Key).name));
				if (!CappedPrefab(item.Key, extra, ignore))
				{
					list.Add(item);
					continue;
				}
				if (!dictionary.TryGetValue(key, out var value))
				{
					value = (dictionary[key] = list.Count);
					dictionary2[key] = 0L;
					list.Add(new KeyValuePair<GameObject, int>(item.Key, 0));
				}
				dictionary2[key] += item.Value;
				list[value] = new KeyValuePair<GameObject, int>(list[value].Key, (int)Math.Min(num, dictionary2[key]));
			}
			__result.Clear();
			__result.AddRange(list);
			if (!Verbose.Value)
			{
				return;
			}
			foreach (KeyValuePair<string, long> item2 in dictionary2)
			{
				if (item2.Value > num)
				{
					Log.LogInfo((object)$"{Prefab(((Object)((Component)val).gameObject).name)} equipment drop {item2.Key}: {item2.Value} -> {num}.");
				}
			}
		}

		private static void RegisterCommand()
		{
			//IL_0033: 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
			object obj = <>c.<>9__45_0;
			if (obj == null)
			{
				ConsoleEvent val = delegate(ConsoleEventArgs args)
				{
					double result;
					int result2;
					if ((Object)(object)ZoneSystem.instance == (Object)null)
					{
						args.Context.AddString("No world loaded.");
					}
					else if (args.Args.Length == 1)
					{
						foreach (string item in from k in ZoneSystem.instance.GetGlobalKeys()
							where k.StartsWith("anri_bosskills_", StringComparison.OrdinalIgnoreCase)
							orderby k
							select k)
						{
							args.Context.AddString(item);
						}
						string key;
						int num = ProgressCap(out key);
						args.Context.AddString($"Progress cap: {num} stars ({key}).");
					}
					else if (args.Args.Length == 4 && args.Args[1].Equals("preview", StringComparison.OrdinalIgnoreCase) && double.TryParse(args.Args[3], NumberStyles.Float, CultureInfo.InvariantCulture, out result) && result >= 0.0 && !double.IsInfinity(result))
					{
						args.Context.AddString($"{Prefab(args.Args[2])}: kills={Count(args.Args[2])}, distance={result.ToString(CultureInfo.InvariantCulture)}m, next spawn={Stars(args.Args[2], result)} stars.");
					}
					else if (args.Args.Length == 3 && int.TryParse(args.Args[2], NumberStyles.Integer, CultureInfo.InvariantCulture, out result2) && result2 >= 0)
					{
						ZoneSystem.instance.SetGlobalKey("anri_bosskills_" + Prefab(args.Args[1]) + " " + result2.ToString(CultureInfo.InvariantCulture));
						args.Context.AddString($"Requested {Prefab(args.Args[1])} counter = {result2}.");
					}
					else
					{
						args.Context.AddString("Usage: bosskills | bosskills <prefab> <n> | bosskills preview <prefab> <distance>");
					}
				};
				<>c.<>9__45_0 = val;
				obj = (object)val;
			}
			new ConsoleCommand("bosskills", "bosskills [<prefab> <n> | preview <prefab> <distance>]", (ConsoleEvent)obj, false, false, false, false, false, false, (ConsoleOptionsFetcher)null, false, false, false);
		}
	}
}