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.Text;
using Microsoft.CodeAnalysis;
using RossQoL.Core.Progression;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("RossQoL.Core")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+49848834b6e16f04c86962471088bb7e32df65a6")]
[assembly: AssemblyProduct("RossQoL.Core")]
[assembly: AssemblyTitle("RossQoL.Core")]
[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 RossQoL.Core.Terrain
{
	public static class HeightLimits
	{
		public const float Vanilla = 8f;

		public const float MinSetting = 1f;

		public const float MaxSetting = 200f;

		public static float Effective(bool active, float configured)
		{
			if (!active)
			{
				return 8f;
			}
			if (float.IsNaN(configured) || float.IsInfinity(configured))
			{
				return 8f;
			}
			return Math.Min(Math.Max(configured, 1f), 200f);
		}
	}
}
namespace RossQoL.Core.Tames
{
	public readonly struct SummonCullCandidate
	{
		public float Health { get; }

		public float MaxHealth { get; }

		public double SecondsSinceSpawned { get; }

		public float HealthFraction
		{
			get
			{
				if (MaxHealth <= 0f)
				{
					return 1f;
				}
				float num = Health / MaxHealth;
				if (num < 0f)
				{
					return 0f;
				}
				if (num > 1f)
				{
					return 1f;
				}
				return num;
			}
		}

		public SummonCullCandidate(float health, float maxHealth, double secondsSinceSpawned)
		{
			Health = health;
			MaxHealth = maxHealth;
			SecondsSinceSpawned = secondsSinceSpawned;
		}
	}
	public static class SummonCullOrder
	{
		public static int Compare(SummonCullCandidate a, SummonCullCandidate b)
		{
			int num = a.HealthFraction.CompareTo(b.HealthFraction);
			if (num != 0)
			{
				return num;
			}
			return b.SecondsSinceSpawned.CompareTo(a.SecondsSinceSpawned);
		}

		public static List<int> Order(IReadOnlyList<SummonCullCandidate> candidates)
		{
			List<int> list = new List<int>();
			if (candidates == null)
			{
				return list;
			}
			for (int i = 0; i < candidates.Count; i++)
			{
				list.Add(i);
			}
			for (int j = 1; j < list.Count; j++)
			{
				int num = list[j];
				SummonCullCandidate b = candidates[num];
				int num2 = j - 1;
				while (num2 >= 0 && Compare(candidates[list[num2]], b) > 0)
				{
					list[num2 + 1] = list[num2];
					num2--;
				}
				list[num2 + 1] = num;
			}
			return list;
		}
	}
}
namespace RossQoL.Core.Startup
{
	public static class ContinuePolicy
	{
		public const int MaxLabelLength = 40;

		private static readonly string[] JoinArguments = new string[4] { "+connect", "+connect_lobby", "-joincode", "-joinserverwithcharacter" };

		public static bool HasJoinArguments(IEnumerable<string> args)
		{
			if (args == null)
			{
				return false;
			}
			foreach (string arg in args)
			{
				string[] joinArguments = JoinArguments;
				foreach (string b in joinArguments)
				{
					if (string.Equals(arg, b, StringComparison.Ordinal))
					{
						return true;
					}
				}
			}
			return false;
		}

		public static bool ShouldShow(LastSession session, bool characterExists, bool worldLoadable, bool launchedWithJoinArguments)
		{
			if (session == null || !session.IsComplete)
			{
				return false;
			}
			if (launchedWithJoinArguments)
			{
				return false;
			}
			if (!characterExists)
			{
				return false;
			}
			if (session.Kind == SessionKind.LocalWorld && !worldLoadable)
			{
				return false;
			}
			return true;
		}

		public static string Label(string characterName, LastSession session)
		{
			string text = "Continue: " + characterName + " on " + session.DisplayName;
			if (text.Length <= 40)
			{
				return text;
			}
			int num = 39;
			if (num > 0 && char.IsHighSurrogate(text[num - 1]))
			{
				num--;
			}
			return text.Substring(0, num) + "…";
		}
	}
	public enum SessionKind
	{
		LocalWorld,
		Server
	}
	public enum ServerKind
	{
		None,
		Dedicated,
		SteamUser,
		PlayFab
	}
	public sealed class LastSession : IEquatable<LastSession>
	{
		public SessionKind Kind { get; }

		public string CharacterFile { get; }

		public string CharacterSource { get; }

		public string WorldName { get; }

		public string WorldSource { get; }

		public ServerKind ServerKind { get; }

		public string ServerAddress { get; }

		public string JoinCode { get; }

		public string DisplayName { get; }

		public bool IsComplete
		{
			get
			{
				if (CharacterFile.Length == 0 || CharacterSource.Length == 0)
				{
					return false;
				}
				if (Kind != SessionKind.LocalWorld)
				{
					if (ServerKind != ServerKind.None)
					{
						return ServerAddress.Length > 0;
					}
					return false;
				}
				if (WorldName.Length > 0)
				{
					return WorldSource.Length > 0;
				}
				return false;
			}
		}

		private LastSession(SessionKind kind, string characterFile, string characterSource, string worldName, string worldSource, ServerKind serverKind, string serverAddress, string joinCode, string displayName)
		{
			Kind = kind;
			CharacterFile = characterFile ?? "";
			CharacterSource = characterSource ?? "";
			WorldName = worldName ?? "";
			WorldSource = worldSource ?? "";
			ServerKind = serverKind;
			ServerAddress = serverAddress ?? "";
			JoinCode = joinCode ?? "";
			DisplayName = displayName ?? "";
		}

		public static LastSession LocalWorld(string characterFile, string characterSource, string worldName, string worldSource)
		{
			return new LastSession(SessionKind.LocalWorld, characterFile, characterSource, worldName, worldSource, ServerKind.None, "", "", worldName);
		}

		public static LastSession Server(string characterFile, string characterSource, ServerKind serverKind, string serverAddress, string joinCode, string displayName)
		{
			return new LastSession(SessionKind.Server, characterFile, characterSource, "", "", serverKind, serverAddress, joinCode, string.IsNullOrEmpty(displayName) ? serverAddress : displayName);
		}

		public bool Equals(LastSession other)
		{
			if (other != null && Kind == other.Kind && CharacterFile == other.CharacterFile && CharacterSource == other.CharacterSource && WorldName == other.WorldName && WorldSource == other.WorldSource && ServerKind == other.ServerKind && ServerAddress == other.ServerAddress && JoinCode == other.JoinCode)
			{
				return DisplayName == other.DisplayName;
			}
			return false;
		}

		public override bool Equals(object obj)
		{
			return Equals(obj as LastSession);
		}

		public override int GetHashCode()
		{
			return ((((((int)Kind * 397) ^ CharacterFile.GetHashCode()) * 397) ^ WorldName.GetHashCode()) * 397) ^ ServerAddress.GetHashCode();
		}

		public override string ToString()
		{
			return $"{Kind} '{DisplayName}' as {CharacterFile}";
		}
	}
	public static class LastSessionFormat
	{
		private const string Version = "1";

		private const char Separator = '|';

		private const char Escape = '\\';

		private const int FieldCount = 10;

		public static string Write(LastSession session)
		{
			if (session == null)
			{
				throw new ArgumentNullException("session");
			}
			string[] array = new string[10]
			{
				"1",
				session.Kind.ToString(),
				session.CharacterFile,
				session.CharacterSource,
				session.WorldName,
				session.WorldSource,
				session.ServerKind.ToString(),
				session.ServerAddress,
				session.JoinCode,
				session.DisplayName
			};
			StringBuilder stringBuilder = new StringBuilder();
			for (int i = 0; i < array.Length; i++)
			{
				if (i > 0)
				{
					stringBuilder.Append('|');
				}
				string text = array[i];
				foreach (char c in text)
				{
					if (c == '|' || c == '\\')
					{
						stringBuilder.Append('\\');
					}
					stringBuilder.Append(c);
				}
			}
			return stringBuilder.ToString();
		}

		public static LastSession Read(string text)
		{
			if (string.IsNullOrEmpty(text))
			{
				return null;
			}
			List<string> list = Split(text);
			if (list == null || list.Count != 10 || list[0] != "1")
			{
				return null;
			}
			if (!TryParseEnum<SessionKind>(list[1], out var value))
			{
				return null;
			}
			if (!TryParseEnum<ServerKind>(list[6], out var value2))
			{
				return null;
			}
			LastSession lastSession = ((value == SessionKind.LocalWorld) ? LastSession.LocalWorld(list[2], list[3], list[4], list[5]) : LastSession.Server(list[2], list[3], value2, list[7], list[8], list[9]));
			if (!lastSession.IsComplete)
			{
				return null;
			}
			return lastSession;
		}

		private static bool TryParseEnum<T>(string text, out T value) where T : struct
		{
			value = default(T);
			if (text.Length == 0)
			{
				return false;
			}
			if (Array.IndexOf(Enum.GetNames(typeof(T)), text) < 0)
			{
				return false;
			}
			return Enum.TryParse<T>(text, ignoreCase: false, out value);
		}

		private static List<string> Split(string text)
		{
			List<string> list = new List<string>();
			StringBuilder stringBuilder = new StringBuilder();
			for (int i = 0; i < text.Length; i++)
			{
				char c = text[i];
				switch (c)
				{
				case '\\':
					if (i + 1 >= text.Length)
					{
						return null;
					}
					stringBuilder.Append(text[++i]);
					break;
				case '|':
					list.Add(stringBuilder.ToString());
					stringBuilder.Clear();
					break;
				default:
					stringBuilder.Append(c);
					break;
				}
			}
			list.Add(stringBuilder.ToString());
			return list;
		}
	}
	public sealed class SessionCapture
	{
		private ServerKind _kind;

		private string _address;

		private string _joinCode;

		private string _displayName;

		public void ServerJoinRequested(ServerKind kind, string address, string joinCode, string displayName)
		{
			_kind = kind;
			_address = address;
			_joinCode = joinCode;
			_displayName = displayName;
		}

		public void LocalWorldStartRequested()
		{
			Clear();
		}

		public LastSession CommitOnInitialSpawn(bool hostingLocalWorld, string characterFile, string characterSource, string worldName, string worldSource)
		{
			LastSession lastSession = (hostingLocalWorld ? LastSession.LocalWorld(characterFile, characterSource, worldName, worldSource) : ((_kind == ServerKind.None) ? null : LastSession.Server(characterFile, characterSource, _kind, _address, _joinCode, _displayName)));
			Clear();
			if (lastSession == null || !lastSession.IsComplete)
			{
				return null;
			}
			return lastSession;
		}

		private void Clear()
		{
			_kind = ServerKind.None;
			_address = null;
			_joinCode = null;
			_displayName = null;
		}
	}
}
namespace RossQoL.Core.Progression
{
	public static class BiomeBosses
	{
		private static readonly Dictionary<string, string> Bosses = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase)
		{
			{ "BlackForest", "defeated_gdking" },
			{ "Swamp", "defeated_bonemass" },
			{ "Mountain", "defeated_dragon" },
			{ "Plains", "defeated_goblinking" }
		};

		public static IEnumerable<string> KnownBiomes => Bosses.Keys;

		public static string KeyFor(string biomeName)
		{
			if (string.IsNullOrEmpty(biomeName))
			{
				return null;
			}
			if (!Bosses.TryGetValue(biomeName, out var value))
			{
				return null;
			}
			return value;
		}

		public static bool IsCleared(string biomeName, Func<string, bool> isKeySet)
		{
			if (isKeySet == null)
			{
				return false;
			}
			string text = KeyFor(biomeName);
			if (text != null)
			{
				return isKeySet(text);
			}
			return false;
		}
	}
	public static class DungeonBosses
	{
		public const string Queen = "defeated_queen";

		private static readonly Dictionary<string, string> Bosses = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase)
		{
			{ "BlackForest", "defeated_gdking" },
			{ "Swamp", "defeated_bonemass" },
			{ "Mountain", "defeated_dragon" },
			{ "Mistlands", "defeated_queen" }
		};

		public static IEnumerable<string> KnownBiomes => Bosses.Keys;

		public static string KeyFor(string biomeName)
		{
			if (string.IsNullOrEmpty(biomeName))
			{
				return null;
			}
			if (!Bosses.TryGetValue(biomeName, out var value))
			{
				return null;
			}
			return value;
		}

		public static bool IsCleared(string biomeName, Func<string, bool> isKeySet)
		{
			if (isKeySet == null)
			{
				return false;
			}
			string text = KeyFor(biomeName);
			if (text != null)
			{
				return isKeySet(text);
			}
			return false;
		}
	}
	public static class DungeonRespawnMath
	{
		public static bool IsDue(int? lastVisitDay, int today, int respawnDays)
		{
			if (!lastVisitDay.HasValue)
			{
				return false;
			}
			if (respawnDays <= 0)
			{
				return false;
			}
			if (today < lastVisitDay.Value)
			{
				return false;
			}
			return today - lastVisitDay.Value >= respawnDays;
		}

		public static int DaysRemaining(int? lastVisitDay, int today, int respawnDays)
		{
			if (!lastVisitDay.HasValue || respawnDays <= 0)
			{
				if (respawnDays <= 0)
				{
					return 0;
				}
				return respawnDays;
			}
			int num = today - lastVisitDay.Value;
			if (num < 0)
			{
				num = 0;
			}
			int num2 = respawnDays - num;
			if (num2 <= 0)
			{
				return 0;
			}
			return num2;
		}
	}
	public static class DungeonUnlock
	{
		private static readonly char[] Separators = new char[4] { ',', ' ', '\t', '|' };

		private static readonly Dictionary<string, string[]> ThemeBosses = new Dictionary<string, string[]>(StringComparer.OrdinalIgnoreCase)
		{
			{
				"SunkenCrypt",
				new string[1] { "defeated_bonemass" }
			},
			{
				"ForestCrypt",
				new string[1] { "defeated_gdking" }
			},
			{
				"ForestCryptHildir",
				new string[1] { "defeated_gdking" }
			},
			{
				"Crypt",
				new string[2] { "defeated_gdking", "defeated_bonemass" }
			},
			{
				"Cave",
				new string[2] { "defeated_gdking", "defeated_dragon" }
			},
			{
				"CaveHildir",
				new string[2] { "defeated_gdking", "defeated_dragon" }
			},
			{
				"DvergerTown",
				new string[1] { "defeated_queen" }
			},
			{
				"DvergerBoss",
				new string[1] { "defeated_queen" }
			}
		};

		public static IEnumerable<string> KnownThemes => ThemeBosses.Keys;

		public static IReadOnlyList<string> KeysForBiomes(string biomeNames)
		{
			List<string> list = Split(biomeNames);
			if (list.Count == 0)
			{
				return null;
			}
			List<string> list2 = new List<string>();
			foreach (string item in list)
			{
				string text = DungeonBosses.KeyFor(item);
				if (text == null)
				{
					return null;
				}
				if (!list2.Contains(text))
				{
					list2.Add(text);
				}
			}
			if (list2.Count <= 0)
			{
				return null;
			}
			return list2;
		}

		public static IReadOnlyList<string> KeysForThemes(string themeNames)
		{
			List<string> list = Split(themeNames);
			if (list.Count == 0)
			{
				return null;
			}
			List<string> list2 = new List<string>();
			foreach (string item2 in list)
			{
				if (!ThemeBosses.TryGetValue(item2, out var value))
				{
					return null;
				}
				string[] array = value;
				foreach (string item in array)
				{
					if (!list2.Contains(item))
					{
						list2.Add(item);
					}
				}
			}
			if (list2.Count <= 0)
			{
				return null;
			}
			return list2;
		}

		public static IReadOnlyList<string> RequiredKeys(string biomeNames, string themeNames)
		{
			return KeysForBiomes(biomeNames) ?? KeysForThemes(themeNames);
		}

		public static bool IsCleared(string biomeNames, string themeNames, Func<string, bool> isKeySet)
		{
			if (isKeySet == null)
			{
				return false;
			}
			IReadOnlyList<string> readOnlyList = RequiredKeys(biomeNames, themeNames);
			if (readOnlyList == null || readOnlyList.Count == 0)
			{
				return false;
			}
			foreach (string item in readOnlyList)
			{
				if (!isKeySet(item))
				{
					return false;
				}
			}
			return true;
		}

		public static string Describe(string biomeNames, string themeNames)
		{
			IReadOnlyList<string> readOnlyList = RequiredKeys(biomeNames, themeNames);
			if (readOnlyList != null && readOnlyList.Count != 0)
			{
				return string.Join(" + ", ToArray(readOnlyList));
			}
			return "nothing we recognise";
		}

		private static List<string> Split(string names)
		{
			List<string> list = new List<string>();
			if (string.IsNullOrEmpty(names))
			{
				return list;
			}
			string[] array = names.Split(Separators, StringSplitOptions.RemoveEmptyEntries);
			foreach (string text in array)
			{
				if (!string.Equals(text, "None", StringComparison.OrdinalIgnoreCase))
				{
					list.Add(text);
				}
			}
			return list;
		}

		private static string[] ToArray(IReadOnlyList<string> keys)
		{
			string[] array = new string[keys.Count];
			for (int i = 0; i < keys.Count; i++)
			{
				array[i] = keys[i];
			}
			return array;
		}
	}
	public static class TeleportUnlocks
	{
		public const string Elder = "defeated_gdking";

		public const string Bonemass = "defeated_bonemass";

		public const string Moder = "defeated_dragon";

		public const string Yagluth = "defeated_goblinking";

		public const string Queen = "defeated_queen";

		public const string Fader = "defeated_fader";

		private static readonly Dictionary<string, string> Unlocks = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase)
		{
			{ "CopperOre", "defeated_gdking" },
			{ "TinOre", "defeated_gdking" },
			{ "Copper", "defeated_gdking" },
			{ "Tin", "defeated_gdking" },
			{ "Bronze", "defeated_gdking" },
			{ "CopperScrap", "defeated_gdking" },
			{ "IronOre", "defeated_bonemass" },
			{ "IronScrap", "defeated_bonemass" },
			{ "Iron", "defeated_bonemass" },
			{ "SilverOre", "defeated_dragon" },
			{ "Silver", "defeated_dragon" },
			{ "DragonEgg", "defeated_dragon" },
			{ "BlackMetalScrap", "defeated_goblinking" },
			{ "BlackMetal", "defeated_goblinking" },
			{ "MechanicalSpring", "defeated_queen" },
			{ "DvergrNeedle", "defeated_queen" },
			{ "FlametalOreNew", "defeated_fader" },
			{ "FlametalNew", "defeated_fader" }
		};

		public static IEnumerable<string> KnownItems => Unlocks.Keys;

		public static string KeyFor(string prefabName)
		{
			if (string.IsNullOrEmpty(prefabName))
			{
				return null;
			}
			if (!Unlocks.TryGetValue(prefabName, out var value))
			{
				return null;
			}
			return value;
		}

		public static bool IsUnlocked(string prefabName, Func<string, bool> isKeySet)
		{
			if (isKeySet == null)
			{
				return false;
			}
			string text = KeyFor(prefabName);
			if (text != null)
			{
				return isKeySet(text);
			}
			return false;
		}
	}
	public static class WorldFrontier
	{
		public const string Eikthyr = "defeated_eikthyr";

		public const string Queen = "defeated_queen";

		public const string Fader = "defeated_fader";

		private static readonly (string Tier, string Key)[] Ladder = new(string, string)[8]
		{
			("Meadows", null),
			("BlackForest", "defeated_eikthyr"),
			("Swamp", "defeated_gdking"),
			("Mountain", "defeated_bonemass"),
			("Plains", "defeated_dragon"),
			("Mistlands", "defeated_goblinking"),
			("Ashlands", "defeated_queen"),
			("DeepNorth", "defeated_fader")
		};

		public static IReadOnlyList<string> Tiers
		{
			get
			{
				List<string> list = new List<string>(Ladder.Length);
				(string, string)[] ladder = Ladder;
				for (int i = 0; i < ladder.Length; i++)
				{
					string item = ladder[i].Item1;
					list.Add(item);
				}
				return list;
			}
		}

		public static string KeyForTier(string tier)
		{
			(string, string)[] ladder = Ladder;
			for (int i = 0; i < ladder.Length; i++)
			{
				var (a, result) = ladder[i];
				if (string.Equals(a, tier, StringComparison.OrdinalIgnoreCase))
				{
					return result;
				}
			}
			return null;
		}

		public static string TierFor(Func<string, bool> isKeySet)
		{
			if (isKeySet == null)
			{
				return Ladder[0].Tier;
			}
			string result = Ladder[0].Tier;
			(string, string)[] ladder = Ladder;
			for (int i = 0; i < ladder.Length; i++)
			{
				var (text, text2) = ladder[i];
				if (text2 != null && isKeySet(text2))
				{
					result = text;
				}
			}
			return result;
		}
	}
}
namespace RossQoL.Core.Production
{
	public static class FeedRules
	{
		public static readonly StringComparer NameComparer = StringComparer.OrdinalIgnoreCase;

		public static Dictionary<string, int> ParseAmounts(string setting)
		{
			Dictionary<string, int> dictionary = new Dictionary<string, int>(NameComparer);
			if (string.IsNullOrWhiteSpace(setting))
			{
				return dictionary;
			}
			string[] array = setting.Split(',');
			for (int i = 0; i < array.Length; i++)
			{
				string text = array[i].Trim();
				if (text.Length == 0)
				{
					continue;
				}
				int num = text.LastIndexOf(':');
				if (num > 0 && num != text.Length - 1)
				{
					string text2 = text.Substring(0, num).Trim();
					string s = text.Substring(num + 1).Trim();
					if (text2.Length != 0 && int.TryParse(s, out var result) && result >= 0)
					{
						dictionary[text2] = result;
					}
				}
			}
			return dictionary;
		}

		public static HashSet<string> ParseNames(string setting)
		{
			HashSet<string> hashSet = new HashSet<string>(NameComparer);
			if (string.IsNullOrWhiteSpace(setting))
			{
				return hashSet;
			}
			string[] array = setting.Split(',');
			for (int i = 0; i < array.Length; i++)
			{
				string text = array[i].Trim();
				if (text.Length > 0)
				{
					hashSet.Add(text);
				}
			}
			return hashSet;
		}

		public static bool Allowed(ICollection<string> allowList, string name)
		{
			if (allowList != null && allowList.Count != 0)
			{
				if (name != null)
				{
					return allowList.Contains(name);
				}
				return false;
			}
			return true;
		}

		public static int MinimumFor(IDictionary<string, int> perItem, string name, int fallback)
		{
			if (name != null && perItem != null && perItem.TryGetValue(name, out var value))
			{
				return Math.Max(0, value);
			}
			return Math.Max(0, fallback);
		}

		public static int Takeable(int available, int wanted, int minimum)
		{
			if (wanted <= 0)
			{
				return 0;
			}
			int num = available - Math.Max(0, minimum);
			if (num <= 0)
			{
				return 0;
			}
			return Math.Min(num, wanted);
		}

		public static bool AtCap(IDictionary<string, int> caps, string product, int existing)
		{
			if (product == null || caps == null)
			{
				return false;
			}
			if (!caps.TryGetValue(product, out var value) || value <= 0)
			{
				return false;
			}
			return existing >= value;
		}
	}
	public static class FermenterReadiness
	{
		public static bool IsReady(int content, long startTicks, long nowTicks, float durationSeconds)
		{
			if (content == 0 || startTicks == 0L)
			{
				return false;
			}
			return (double)(nowTicks - startTicks) / 10000000.0 > (double)durationSeconds;
		}
	}
	public static class HarvestMath
	{
		public static int Room(int freeStackSpace, int emptySlots, int maxStackSize)
		{
			long num = Math.Max(0, freeStackSpace) + (long)Math.Max(0, emptySlots) * (long)Math.Max(1, maxStackSize);
			if (num <= int.MaxValue)
			{
				return (int)num;
			}
			return int.MaxValue;
		}

		public static int UnitsTaken(int placed, int unitSize)
		{
			if (placed <= 0)
			{
				return 0;
			}
			long num = Math.Max(1, unitSize);
			return (int)((placed + num - 1) / num);
		}

		public static int Shortfall(int placed, int unitSize)
		{
			if (placed <= 0)
			{
				return 0;
			}
			return (int)((long)UnitsTaken(placed, unitSize) * (long)Math.Max(1, unitSize) - placed);
		}

		public static bool IsDue(double? lastAttempt, double now, double intervalSeconds)
		{
			if (!lastAttempt.HasValue)
			{
				return true;
			}
			double num = now - lastAttempt.Value;
			if (!(num < 0.0))
			{
				return num >= Math.Max(0.0, intervalSeconds);
			}
			return true;
		}
	}
	public readonly struct DestinationCandidate
	{
		public int Index { get; }

		public bool HoldsItem { get; }

		public int Room { get; }

		public float DistanceSquared { get; }

		public DestinationCandidate(int index, bool holdsItem, int room, float distanceSquared)
		{
			Index = index;
			HoldsItem = holdsItem;
			Room = room;
			DistanceSquared = distanceSquared;
		}
	}
	public readonly struct Placement
	{
		public int Index { get; }

		public int Amount { get; }

		public Placement(int index, int amount)
		{
			Index = index;
			Amount = amount;
		}
	}
	public static class HarvestPlan
	{
		public static List<DestinationCandidate> Rank(IEnumerable<DestinationCandidate> candidates)
		{
			if (candidates == null)
			{
				return new List<DestinationCandidate>();
			}
			return (from c in candidates
				where c.Room > 0
				orderby c.HoldsItem descending, c.DistanceSquared, c.Index
				select c).ToList();
		}

		public static List<Placement> Plan(int amount, int unitSize, IReadOnlyList<DestinationCandidate> ranked, bool wholeOnly)
		{
			List<Placement> list = new List<Placement>();
			if (amount <= 0 || ranked == null)
			{
				return list;
			}
			int num = Math.Max(1, unitSize);
			int num2 = amount - amount % num;
			foreach (DestinationCandidate item in ranked)
			{
				if (num2 <= 0)
				{
					break;
				}
				int num3 = Math.Min(num2, item.Room);
				num3 -= num3 % num;
				if (num3 > 0)
				{
					list.Add(new Placement(item.Index, num3));
					num2 -= num3;
				}
			}
			if (wholeOnly && list.Sum((Placement p) => p.Amount) < amount)
			{
				list.Clear();
			}
			return list;
		}
	}
}
namespace RossQoL.Core.Portals
{
	public static class ArrivalPlacement
	{
		private const float RingStep = 1.5f;

		private static readonly float[] AngleOffsetsDegrees = new float[14]
		{
			0f, 25f, -25f, 50f, -50f, 75f, -75f, 100f, -100f, 130f,
			-130f, 160f, -160f, 180f
		};

		public static Vec3[] Compute(Vec3 arrival, Vec3 facing, int count, float searchDistance, Func<Vec3, bool> isFree)
		{
			if (count <= 0)
			{
				return Array.Empty<Vec3>();
			}
			if (isFree == null)
			{
				isFree = (Vec3 _) => true;
			}
			(float X, float Z) tuple = Normalise(facing);
			float item = tuple.X;
			float item2 = tuple.Z;
			Vec3[] array = new Vec3[count];
			List<Vec3> list = new List<Vec3>(count);
			for (int num = 0; num < count; num++)
			{
				array[num] = FindSpot(arrival, item, item2, searchDistance, isFree, list);
				list.Add(array[num]);
			}
			return array;
		}

		private static Vec3 FindSpot(Vec3 arrival, float fx, float fz, float searchDistance, Func<Vec3, bool> isFree, List<Vec3> taken)
		{
			if (searchDistance <= 0f)
			{
				return arrival;
			}
			for (float num = Math.Min(1.5f, searchDistance); num <= searchDistance + 0.001f; num += 1.5f)
			{
				float[] angleOffsetsDegrees = AngleOffsetsDegrees;
				foreach (float degrees in angleOffsetsDegrees)
				{
					Vec3 vec = Rotate(arrival, fx, fz, num, degrees);
					if (isFree(vec) && !IsTaken(taken, vec))
					{
						return vec;
					}
				}
			}
			return arrival;
		}

		private static bool IsTaken(List<Vec3> taken, Vec3 candidate)
		{
			for (int i = 0; i < taken.Count; i++)
			{
				if (Vec3.DistanceSquared(taken[i], candidate) < 1f)
				{
					return true;
				}
			}
			return false;
		}

		private static Vec3 Rotate(Vec3 origin, float fx, float fz, float radius, float degrees)
		{
			double num = (double)degrees * Math.PI / 180.0;
			double num2 = Math.Cos(num);
			double num3 = Math.Sin(num);
			float num4 = (float)((double)fx * num2 - (double)fz * num3);
			float num5 = (float)((double)fx * num3 + (double)fz * num2);
			return new Vec3(origin.X + num4 * radius, origin.Y, origin.Z + num5 * radius);
		}

		private static (float X, float Z) Normalise(Vec3 facing)
		{
			float num = (float)Math.Sqrt(facing.X * facing.X + facing.Z * facing.Z);
			if (!float.IsFinite(num) || num < 0.0001f)
			{
				return (X: 0f, Z: 1f);
			}
			return (X: facing.X / num, Z: facing.Z / num);
		}
	}
	public static class PlacementFooting
	{
		public const float SameFloorToleranceMetres = 1.5f;

		public const float UnderTerrainMarginMetres = 1f;

		public static bool IsAcceptable(bool floorFound, float floorHeight, float playerHeight, float toleranceMetres, bool terrainFound, float terrainHeight, bool playerIsUnderTerrain, float underTerrainMarginMetres)
		{
			if (!IsStandingRoom(floorFound, floorHeight, playerHeight, toleranceMetres))
			{
				return false;
			}
			if (playerIsUnderTerrain)
			{
				return true;
			}
			return !IsUnderTerrain(floorHeight, terrainFound, terrainHeight, underTerrainMarginMetres);
		}

		public static bool IsStandingRoom(bool floorFound, float floorHeight, float playerHeight, float toleranceMetres)
		{
			if (!floorFound)
			{
				return false;
			}
			if (!IsFinite(floorHeight) || !IsFinite(playerHeight))
			{
				return false;
			}
			return Math.Abs(floorHeight - playerHeight) <= Math.Max(0f, toleranceMetres);
		}

		public static bool IsUnderTerrain(float height, bool terrainFound, float terrainHeight, float marginMetres)
		{
			if (!terrainFound)
			{
				return false;
			}
			if (!IsFinite(height) || !IsFinite(terrainHeight))
			{
				return false;
			}
			return height < terrainHeight - Math.Max(0f, marginMetres);
		}

		private static bool IsFinite(float value)
		{
			if (!float.IsNaN(value))
			{
				return !float.IsInfinity(value);
			}
			return false;
		}
	}
	public readonly struct TameCandidate
	{
		public Vec3 Position { get; }

		public bool IsTamed { get; }

		public bool IsFollowingPlayer { get; }

		public bool IsBusy { get; }

		public bool IsSummon { get; }

		public TameCandidate(Vec3 position, bool isTamed, bool isFollowingPlayer, bool isBusy, bool isSummon = false)
		{
			Position = position;
			IsTamed = isTamed;
			IsFollowingPlayer = isFollowingPlayer;
			IsBusy = isBusy;
			IsSummon = isSummon;
		}
	}
	public static class TameEligibility
	{
		public static bool Qualifies(TameCandidate candidate, Vec3 playerPosition, float radius)
		{
			if (radius <= 0f)
			{
				return false;
			}
			if (!candidate.IsTamed && !candidate.IsSummon)
			{
				return false;
			}
			if (!candidate.IsFollowingPlayer)
			{
				return false;
			}
			if (candidate.IsBusy)
			{
				return false;
			}
			return Vec3.DistanceSquared(candidate.Position, playerPosition) <= radius * radius;
		}

		public static List<int> SelectIndices(IReadOnlyList<TameCandidate> candidates, Vec3 playerPosition, float radius)
		{
			List<int> list = new List<int>();
			if (candidates == null)
			{
				return list;
			}
			for (int i = 0; i < candidates.Count; i++)
			{
				if (Qualifies(candidates[i], playerPosition, radius))
				{
					list.Add(i);
				}
			}
			return list;
		}
	}
	public enum TameMoveOutcome
	{
		Moved,
		NoId,
		NoZdoMan,
		ZdoMissing,
		OwnershipRefused
	}
	public static class TameMoveOutcomes
	{
		public static TameMoveOutcome Classify(bool hasId, bool networkReady, bool zdoFound, bool ownershipHeld)
		{
			if (!hasId)
			{
				return TameMoveOutcome.NoId;
			}
			if (!networkReady)
			{
				return TameMoveOutcome.NoZdoMan;
			}
			if (!zdoFound)
			{
				return TameMoveOutcome.ZdoMissing;
			}
			if (!ownershipHeld)
			{
				return TameMoveOutcome.OwnershipRefused;
			}
			return TameMoveOutcome.Moved;
		}

		public static bool Arrived(TameMoveOutcome outcome)
		{
			return outcome == TameMoveOutcome.Moved;
		}
	}
	public readonly struct Vec3 : IEquatable<Vec3>
	{
		public static readonly Vec3 Zero = new Vec3(0f, 0f, 0f);

		public float X { get; }

		public float Y { get; }

		public float Z { get; }

		public Vec3(float x, float y, float z)
		{
			X = x;
			Y = y;
			Z = z;
		}

		public Vec3 WithY(float y)
		{
			return new Vec3(X, y, Z);
		}

		public static Vec3 operator +(Vec3 a, Vec3 b)
		{
			return new Vec3(a.X + b.X, a.Y + b.Y, a.Z + b.Z);
		}

		public static Vec3 operator *(Vec3 a, float s)
		{
			return new Vec3(a.X * s, a.Y * s, a.Z * s);
		}

		public static float DistanceSquared(Vec3 a, Vec3 b)
		{
			float num = a.X - b.X;
			float num2 = a.Y - b.Y;
			float num3 = a.Z - b.Z;
			return num * num + num2 * num2 + num3 * num3;
		}

		public bool Equals(Vec3 other)
		{
			if (X == other.X && Y == other.Y)
			{
				return Z == other.Z;
			}
			return false;
		}

		public override bool Equals(object obj)
		{
			if (obj is Vec3 other)
			{
				return Equals(other);
			}
			return false;
		}

		public override int GetHashCode()
		{
			return (((X.GetHashCode() * 397) ^ Y.GetHashCode()) * 397) ^ Z.GetHashCode();
		}

		public override string ToString()
		{
			return $"({X:F2}, {Y:F2}, {Z:F2})";
		}
	}
}
namespace RossQoL.Core.Items
{
	public static class ItemDecayRule
	{
		public const double AutoDestroySeconds = 3600.0;

		public const float PlayerRangeMetres = 25f;

		public static bool ShouldDestroy(double ageSeconds, bool playerNearby, bool inTar, bool isDebris, bool ignoreBaseExemption)
		{
			if (!ignoreBaseExemption)
			{
				return false;
			}
			if (ageSeconds < 3600.0)
			{
				return false;
			}
			if (playerNearby)
			{
				return false;
			}
			if (inTar)
			{
				return false;
			}
			if (isDebris)
			{
				return false;
			}
			return true;
		}
	}
	public enum RecallAttackAction
	{
		PlayNow,
		RetireThenPlay,
		Refuse
	}
	public static class RecallAttackHandover
	{
		public static RecallAttackAction Decide(bool hasCurrentAttack, bool currentAttackDone)
		{
			if (!hasCurrentAttack)
			{
				return RecallAttackAction.PlayNow;
			}
			if (!currentAttackDone)
			{
				return RecallAttackAction.Refuse;
			}
			return RecallAttackAction.RetireThenPlay;
		}
	}
	public static class RecallCast
	{
		public static bool IsComplete(float startedAt, float now, float castSeconds)
		{
			if (castSeconds <= 0f)
			{
				return true;
			}
			return now - startedAt >= castSeconds;
		}
	}
	public static class RecallCooldown
	{
		public static bool CanFire(float? lastUsed, float now, float cooldownSeconds)
		{
			if (cooldownSeconds <= 0f)
			{
				return true;
			}
			if (!lastUsed.HasValue)
			{
				return true;
			}
			return now - lastUsed.Value >= cooldownSeconds;
		}
	}
	public static class SummonKinds
	{
		public const string SkeletonPrefab = "Skeleton_Friendly";

		public const string SpiritCallerSuffix = "_spiritcaller";

		public const string DeadRaiserStaff = "StaffSkeleton";

		public const string SpiritCallerStaff = "StaffSpiritCaller";

		private const string CloneSuffix = "(Clone)";

		public static bool IsSummon(string prefabName)
		{
			string text = Strip(prefabName);
			if (text.Length == 0)
			{
				return false;
			}
			if (!text.Equals("Skeleton_Friendly", StringComparison.OrdinalIgnoreCase))
			{
				if (text.Length > "_spiritcaller".Length)
				{
					return text.EndsWith("_spiritcaller", StringComparison.OrdinalIgnoreCase);
				}
				return false;
			}
			return true;
		}

		public static bool IsRecallStaff(string prefabName)
		{
			string text = Strip(prefabName);
			if (!text.Equals("StaffSkeleton", StringComparison.OrdinalIgnoreCase))
			{
				return text.Equals("StaffSpiritCaller", StringComparison.OrdinalIgnoreCase);
			}
			return true;
		}

		private static string Strip(string name)
		{
			if (string.IsNullOrEmpty(name))
			{
				return "";
			}
			if (!name.EndsWith("(Clone)", StringComparison.Ordinal))
			{
				return name;
			}
			return name.Substring(0, name.Length - "(Clone)".Length);
		}
	}
	public readonly struct SummonKind
	{
		public bool Available { get; }

		public int Following { get; }

		public float WeakestHealthFraction { get; }

		public SummonKind(bool available, int following, float weakestHealthFraction)
		{
			Available = available;
			Following = following;
			WeakestHealthFraction = weakestHealthFraction;
		}
	}
	public static class SummonPick
	{
		public const float HealthTieTolerance = 0.005f;

		public static int Choose(IReadOnlyList<SummonKind> kinds, Func<int, int> randomBelow)
		{
			if (kinds == null || randomBelow == null)
			{
				return -1;
			}
			List<int> list = new List<int>();
			List<int> list2 = new List<int>();
			for (int i = 0; i < kinds.Count; i++)
			{
				if (kinds[i].Available)
				{
					((kinds[i].Following <= 0) ? list : list2).Add(i);
				}
			}
			if (list.Count > 0)
			{
				return PickAmong(list, randomBelow);
			}
			if (list2.Count == 0)
			{
				return -1;
			}
			float num = float.MaxValue;
			foreach (int item in list2)
			{
				num = Math.Min(num, Clamp01(kinds[item].WeakestHealthFraction));
			}
			List<int> list3 = new List<int>();
			foreach (int item2 in list2)
			{
				if (Clamp01(kinds[item2].WeakestHealthFraction) - num <= 0.005f)
				{
					list3.Add(item2);
				}
			}
			return PickAmong(list3, randomBelow);
		}

		public static int MostPerCast(int minToSpawn, int maxToSpawn)
		{
			if (maxToSpawn <= minToSpawn)
			{
				return minToSpawn;
			}
			return maxToSpawn - 1;
		}

		private static int PickAmong(List<int> indices, Func<int, int> randomBelow)
		{
			if (indices.Count == 1)
			{
				return indices[0];
			}
			int num = randomBelow(indices.Count);
			if (num < 0 || num >= indices.Count)
			{
				num = 0;
			}
			return indices[num];
		}

		private static float Clamp01(float value)
		{
			if (float.IsNaN(value))
			{
				return 1f;
			}
			if (value < 0f)
			{
				return 0f;
			}
			if (!(value > 1f))
			{
				return value;
			}
			return 1f;
		}
	}
}
namespace RossQoL.Core.Interface
{
	public static class ClockText
	{
		private const int MinutesPerDay = 1440;

		public static string Format(string dayLabel, float dayFraction, bool use24Hour)
		{
			string text = FormatTime(dayFraction, use24Hour);
			if (!string.IsNullOrEmpty(dayLabel))
			{
				return dayLabel + "  " + text;
			}
			return text;
		}

		private static string FormatTime(float dayFraction, bool use24Hour)
		{
			double num = ((float.IsNaN(dayFraction) || float.IsInfinity(dayFraction)) ? 0.0 : ((double)dayFraction));
			int num2 = (int)Math.Floor((num - Math.Floor(num)) * 1440.0) % 1440;
			int num3 = num2 / 60;
			int num4 = num2 % 60;
			if (use24Hour)
			{
				return $"{num3:00}:{num4:00}";
			}
			int num5 = ((num3 % 12 == 0) ? 12 : (num3 % 12));
			return string.Format("{0}:{1:00} {2}", num5, num4, (num3 < 12) ? "AM" : "PM");
		}
	}
	public enum NotificationStyle
	{
		Plain,
		Count,
		Progress
	}
	public sealed class Notification
	{
		public string Key { get; }

		public string Label { get; internal set; }

		public NotificationStyle Style { get; internal set; }

		public float Amount { get; internal set; }

		public float Share { get; internal set; }

		public float RefreshedAt { get; internal set; }

		public string Text
		{
			get
			{
				switch (Style)
				{
				case NotificationStyle.Count:
				{
					int num = (int)Math.Round(Amount, MidpointRounding.AwayFromZero);
					if (num <= 1)
					{
						return Label;
					}
					return Label + " x" + num.ToString(CultureInfo.InvariantCulture);
				}
				case NotificationStyle.Progress:
					return Label + " " + SkillProgress.FormatGain(Amount, Share);
				default:
					return Label;
				}
			}
		}

		internal Notification(string key, string label, NotificationStyle style, float amount, float share, float now)
		{
			Key = key;
			Label = label;
			Style = style;
			Amount = amount;
			Share = share;
			RefreshedAt = now;
		}
	}
	public sealed class NotificationList
	{
		public const int DefaultCapacity = 5;

		public const float DefaultHoldSeconds = 1f;

		public const float DefaultFadeSeconds = 4f;

		private readonly List<Notification> _entries = new List<Notification>();

		public int Capacity { get; }

		public float HoldSeconds { get; }

		public float FadeSeconds { get; }

		public IReadOnlyList<Notification> Entries => _entries;

		public int Count => _entries.Count;

		public NotificationList(int capacity = 5, float holdSeconds = 1f, float fadeSeconds = 4f)
		{
			Capacity = Math.Max(1, capacity);
			HoldSeconds = Math.Max(0f, holdSeconds);
			FadeSeconds = Math.Max(0f, fadeSeconds);
		}

		public Notification Add(string key, string label, NotificationStyle style, float amount, float now)
		{
			return Fold(key, label, style, amount, 0f, now);
		}

		public Notification AddProgress(string key, string label, float gain, float percent, float now)
		{
			return Fold(key, label, NotificationStyle.Progress, gain, percent, now);
		}

		private Notification Fold(string key, string label, NotificationStyle style, float amount, float share, float now)
		{
			if (key == null)
			{
				throw new ArgumentNullException("key");
			}
			Notification notification = Find(key);
			if (notification != null)
			{
				bool flag = notification.Style == style;
				notification.Label = label;
				notification.Amount = (flag ? (notification.Amount + amount) : amount);
				notification.Share = (flag ? (notification.Share + share) : share);
				notification.Style = style;
				notification.RefreshedAt = now;
				return notification;
			}
			if (_entries.Count >= Capacity)
			{
				_entries.RemoveAt(0);
			}
			Notification notification2 = new Notification(key, label, style, amount, share, now);
			_entries.Add(notification2);
			return notification2;
		}

		public Notification Find(string key)
		{
			for (int i = 0; i < _entries.Count; i++)
			{
				if (string.Equals(_entries[i].Key, key, StringComparison.Ordinal))
				{
					return _entries[i];
				}
			}
			return null;
		}

		public bool Remove(string key)
		{
			Notification notification = Find(key);
			if (notification != null)
			{
				return _entries.Remove(notification);
			}
			return false;
		}

		public void Clear()
		{
			_entries.Clear();
		}

		public void Prune(float now)
		{
			for (int num = _entries.Count - 1; num >= 0; num--)
			{
				if (AlphaOf(_entries[num], now) <= 0f)
				{
					_entries.RemoveAt(num);
				}
			}
		}

		public float AlphaOf(Notification entry, float now)
		{
			if (entry == null)
			{
				return 0f;
			}
			float num = now - entry.RefreshedAt;
			if (num <= HoldSeconds)
			{
				return 1f;
			}
			if (FadeSeconds <= 0f)
			{
				return 0f;
			}
			float num2 = 1f - (num - HoldSeconds) / FadeSeconds;
			if (num2 <= 0f)
			{
				return 0f;
			}
			if (!(num2 >= 1f))
			{
				return num2;
			}
			return 1f;
		}
	}
	public static class ProductionTimer
	{
		public static double SecondsToNextUnit(double product, double secPerUnit)
		{
			if (secPerUnit <= 0.0)
			{
				return 0.0;
			}
			double num = secPerUnit - product;
			if (!(num > 0.0))
			{
				return 0.0;
			}
			return num;
		}

		public static double SecondsToFull(double product, double secPerUnit, int level, int maxLevel)
		{
			if (secPerUnit <= 0.0 || level >= maxLevel)
			{
				return 0.0;
			}
			double num = (double)(maxLevel - level) * secPerUnit - product;
			if (!(num > 0.0))
			{
				return 0.0;
			}
			return num;
		}

		public static double SecondsUntilReady(long startTicks, long nowTicks, double durationSeconds)
		{
			if (startTicks <= 0)
			{
				return -1.0;
			}
			double num = (double)(nowTicks - startTicks) / 10000000.0;
			double num2 = durationSeconds - num;
			if (!(num2 > 0.0))
			{
				return 0.0;
			}
			return num2;
		}

		public static string Format(double seconds)
		{
			if (seconds <= 0.0)
			{
				return "0s";
			}
			long num = (long)Math.Ceiling(seconds);
			long num2 = num / 3600;
			long num3 = num % 3600 / 60;
			long num4 = num % 60;
			if (num2 > 0)
			{
				return $"{num2}h {num3:00}m";
			}
			if (num3 > 0)
			{
				return $"{num3}m {num4:00}s";
			}
			return $"{num4}s";
		}
	}
	public static class SkillProgress
	{
		public const float MaxLevel = 100f;

		private const float SmallestValue = 0.1f;

		private const float SmallestPercent = 1f;

		public static float NextLevelRequirement(float level)
		{
			if (level < 0f)
			{
				level = 0f;
			}
			return (float)(Math.Pow(Math.Floor(level + 1f), 1.5) * 0.5 + 0.5);
		}

		public static float PercentOfLevel(float gain, float level)
		{
			if (gain <= 0f)
			{
				return 0f;
			}
			float num = NextLevelRequirement(level);
			if (num <= 0f)
			{
				return 0f;
			}
			return gain / num * 100f;
		}

		public static string FormatGain(float gain, float percent)
		{
			return "+" + FormatValue(gain) + " (" + FormatPercent(percent) + ")";
		}

		public static string FormatValue(float gain)
		{
			if (gain <= 0f)
			{
				return "0";
			}
			if (gain < 0.1f)
			{
				return "<0.1";
			}
			return Math.Round(gain, 1, MidpointRounding.AwayFromZero).ToString("0.#", CultureInfo.InvariantCulture);
		}

		public static string FormatPercent(float percent)
		{
			if (percent <= 0f)
			{
				return "0%";
			}
			if (percent < 1f)
			{
				return "<1%";
			}
			return ((int)Math.Round(percent, MidpointRounding.AwayFromZero)).ToString(CultureInfo.InvariantCulture) + "%";
		}
	}
}
namespace RossQoL.Core.Framework
{
	public sealed class ConfigReloadSchedule
	{
		public static readonly TimeSpan Debounce = TimeSpan.FromSeconds(0.5);

		public static readonly TimeSpan PollInterval = TimeSpan.FromSeconds(0.5);

		public static readonly TimeSpan RetryDelay = TimeSpan.FromSeconds(2.0);

		private DateTime _lastKnownWriteUtc;

		private DateTime _dueUtc;

		private DateTime _lastPollUtc = DateTime.MinValue;

		private bool _pending;

		public ConfigReloadSchedule(DateTime initialWriteUtc)
		{
			_lastKnownWriteUtc = initialWriteUtc;
		}

		public bool TakePollDue(DateTime nowUtc)
		{
			if (_lastPollUtc != DateTime.MinValue && nowUtc - _lastPollUtc < PollInterval)
			{
				return false;
			}
			_lastPollUtc = nowUtc;
			return true;
		}

		public void ObserveWriteTime(DateTime writeUtc, DateTime nowUtc)
		{
			if (!(writeUtc == DateTime.MinValue) && !(writeUtc == _lastKnownWriteUtc))
			{
				_lastKnownWriteUtc = writeUtc;
				NotifyChanged(nowUtc);
			}
		}

		public void NotifyChanged(DateTime nowUtc)
		{
			_pending = true;
			_dueUtc = nowUtc + Debounce;
		}

		public bool TakeDueReload(DateTime nowUtc)
		{
			if (!_pending || nowUtc < _dueUtc)
			{
				return false;
			}
			_pending = false;
			return true;
		}

		public void Reloaded(DateTime nowUtc, DateTime writeUtc)
		{
			if (writeUtc != DateTime.MinValue)
			{
				_lastKnownWriteUtc = writeUtc;
			}
		}

		public void ReloadFailed(DateTime nowUtc)
		{
			_pending = true;
			_dueUtc = nowUtc + RetryDelay;
		}
	}
	public enum FeatureScope
	{
		Client,
		Synced
	}
	public static class FeatureRules
	{
		public static bool IsActive(bool categoryEnabled, bool featureEnabled)
		{
			return categoryEnabled && featureEnabled;
		}

		public static FeatureScope CategoryScope(IEnumerable<FeatureScope> featureScopes)
		{
			if (featureScopes == null)
			{
				return FeatureScope.Client;
			}
			foreach (FeatureScope featureScope in featureScopes)
			{
				if (featureScope == FeatureScope.Synced)
				{
					return FeatureScope.Synced;
				}
			}
			return FeatureScope.Client;
		}

		public static bool ShouldPatch(FeatureScope scope, bool activeAtStartup, bool requiredMembersPresent)
		{
			if (!requiredMembersPresent)
			{
				return false;
			}
			return scope == FeatureScope.Synced || activeAtStartup;
		}

		public static string Describe(string text, FeatureScope scope, bool requiresRestart, bool turningOnRequiresRestart = false)
		{
			string text2 = ((scope == FeatureScope.Synced) ? " Server-controlled when connected." : " Personal setting.");
			string text3 = (requiresRestart ? " Requires restart." : (turningOnRequiresRestart ? " Turning it on requires a restart." : ""));
			return text + text2 + text3;
		}
	}
}
namespace RossQoL.Core.Death
{
	public static class CorpseRunStrength
	{
		public static float For(float distance, float minDistance, float fullDistance)
		{
			float num = Math.Max(0f, minDistance);
			float num2 = distance - num;
			if (num2 <= 0f)
			{
				return 0f;
			}
			if (fullDistance <= 0f)
			{
				return 1f;
			}
			return Clamp01(num2 / fullDistance);
		}

		public static float WithBaseline(float strength, float baseline)
		{
			float num = Clamp01(baseline);
			return num + (1f - num) * Clamp01(strength);
		}

		public static float RegenMultiplier(float strength, float maxRegenBonus)
		{
			return 1f + Clamp01(strength) * Math.Max(0f, maxRegenBonus);
		}

		public static float DrainModifier(float strength, float maxDrainReduction)
		{
			return (0f - Clamp01(strength)) * Clamp01(maxDrainReduction);
		}

		private static float Clamp01(float value)
		{
			if (!(value < 0f))
			{
				if (!(value > 1f))
				{
					return value;
				}
				return 1f;
			}
			return 0f;
		}
	}
	public static class CorpseRunTimeout
	{
		public static bool Expired(float startSeconds, float nowSeconds, float limitMinutes)
		{
			if (limitMinutes <= 0f)
			{
				return false;
			}
			return nowSeconds - startSeconds >= limitMinutes * 60f;
		}
	}
	public enum GraveAimTarget
	{
		Grave,
		Entrance
	}
	public static class GraveAim
	{
		public const float InteriorHeight = 3000f;

		public static bool InInterior(float y)
		{
			return y > 3000f;
		}

		public static GraveAimTarget Choose(float graveY, bool hasEntrance, float playerY)
		{
			if (!hasEntrance)
			{
				return GraveAimTarget.Grave;
			}
			if (!InInterior(graveY))
			{
				return GraveAimTarget.Grave;
			}
			if (!InInterior(playerY))
			{
				return GraveAimTarget.Entrance;
			}
			return GraveAimTarget.Grave;
		}
	}
	public enum GraveVerdict
	{
		Ignore,
		Observe,
		Forget
	}
	public static class GraveClearRule
	{
		public const float MatchRadius = 8f;

		public static bool Matches(float gx, float gy, float gz, float tx, float ty, float tz)
		{
			float num = gx - tx;
			float num2 = gy - ty;
			float num3 = gz - tz;
			return num * num + num2 * num2 + num3 * num3 <= 64f;
		}

		public static GraveVerdict Decide(bool inRange, bool tombstoneStanding, bool seenThisSession, bool armed)
		{
			if (!inRange)
			{
				return GraveVerdict.Ignore;
			}
			if (tombstoneStanding)
			{
				return GraveVerdict.Observe;
			}
			if (seenThisSession && armed)
			{
				return GraveVerdict.Forget;
			}
			return GraveVerdict.Ignore;
		}
	}
	public static class GraveConsumers
	{
		public const string GraveMarker = "GraveMarker";

		public const string RespawnFood = "RespawnFood";

		public const string RespawnRested = "RespawnRested";

		public const string CorpseRun = "CorpseRun";

		public static bool NeedsGraveRecord(string featureKey)
		{
			if (!(featureKey == "GraveMarker"))
			{
				return featureKey == "CorpseRun";
			}
			return true;
		}

		public static bool NeedsDiedFlag(string featureKey)
		{
			if (!(featureKey == "RespawnFood"))
			{
				return featureKey == "RespawnRested";
			}
			return true;
		}

		public static bool AnyNeedsGraveRecord(IEnumerable<string> activeFeatureKeys)
		{
			return Any(activeFeatureKeys, NeedsGraveRecord);
		}

		public static bool AnyNeedsDiedFlag(IEnumerable<string> activeFeatureKeys)
		{
			return Any(activeFeatureKeys, NeedsDiedFlag);
		}

		private static bool Any(IEnumerable<string> keys, Func<string, bool> wants)
		{
			if (keys == null)
			{
				return false;
			}
			foreach (string key in keys)
			{
				if (key != null && wants(key))
				{
					return true;
				}
			}
			return false;
		}
	}
	public readonly struct GraveRecord
	{
		private const char FieldSeparator = ';';

		private const int PlainFieldCount = 8;

		private const int WithEntranceFieldCount = 11;

		public long WorldId { get; }

		public float X { get; }

		public float Y { get; }

		public float Z { get; }

		public int Day { get; }

		public int Items { get; }

		public long ZdoUserId { get; }

		public uint ZdoId { get; }

		public bool HasEntrance { get; }

		public float EntranceX { get; }

		public float EntranceY { get; }

		public float EntranceZ { get; }

		public GraveRecord(long worldId, float x, float y, float z, int day, int items, long zdoUserId, uint zdoId)
			: this(worldId, x, y, z, day, items, zdoUserId, zdoId, hasEntrance: false, 0f, 0f, 0f)
		{
		}

		public GraveRecord(long worldId, float x, float y, float z, int day, int items, long zdoUserId, uint zdoId, float entranceX, float entranceY, float entranceZ)
			: this(worldId, x, y, z, day, items, zdoUserId, zdoId, hasEntrance: true, entranceX, entranceY, entranceZ)
		{
		}

		private GraveRecord(long worldId, float x, float y, float z, int day, int items, long zdoUserId, uint zdoId, bool hasEntrance, float entranceX, float entranceY, float entranceZ)
		{
			WorldId = worldId;
			X = x;
			Y = y;
			Z = z;
			Day = day;
			Items = items;
			ZdoUserId = zdoUserId;
			ZdoId = zdoId;
			HasEntrance = hasEntrance;
			EntranceX = entranceX;
			EntranceY = entranceY;
			EntranceZ = entranceZ;
		}

		public string Format()
		{
			string text = string.Join(';'.ToString(), WorldId.ToString(CultureInfo.InvariantCulture), X.ToString("R", CultureInfo.InvariantCulture), Y.ToString("R", CultureInfo.InvariantCulture), Z.ToString("R", CultureInfo.InvariantCulture), Day.ToString(CultureInfo.InvariantCulture), Items.ToString(CultureInfo.InvariantCulture), ZdoUserId.ToString(CultureInfo.InvariantCulture), ZdoId.ToString(CultureInfo.InvariantCulture));
			if (!HasEntrance)
			{
				return text;
			}
			return string.Join(';'.ToString(), text, EntranceX.ToString("R", CultureInfo.InvariantCulture), EntranceY.ToString("R", CultureInfo.InvariantCulture), EntranceZ.ToString("R", CultureInfo.InvariantCulture));
		}

		public static bool TryParse(string line, out GraveRecord record)
		{
			record = default(GraveRecord);
			if (string.IsNullOrWhiteSpace(line))
			{
				return false;
			}
			string[] array = line.Split(';');
			bool flag = array.Length == 11;
			if (array.Length != 8 && !flag)
			{
				return false;
			}
			CultureInfo invariantCulture = CultureInfo.InvariantCulture;
			if (!long.TryParse(array[0], NumberStyles.Integer, invariantCulture, out var result))
			{
				return false;
			}
			if (!float.TryParse(array[1], NumberStyles.Float, invariantCulture, out var result2))
			{
				return false;
			}
			if (!float.TryParse(array[2], NumberStyles.Float, invariantCulture, out var result3))
			{
				return false;
			}
			if (!float.TryParse(array[3], NumberStyles.Float, invariantCulture, out var result4))
			{
				return false;
			}
			if (!int.TryParse(array[4], NumberStyles.Integer, invariantCulture, out var result5))
			{
				return false;
			}
			if (!int.TryParse(array[5], NumberStyles.Integer, invariantCulture, out var result6))
			{
				return false;
			}
			if (!long.TryParse(array[6], NumberStyles.Integer, invariantCulture, out var result7))
			{
				return false;
			}
			if (!uint.TryParse(array[7], NumberStyles.Integer, invariantCulture, out var result8))
			{
				return false;
			}
			if (!flag)
			{
				record = new GraveRecord(result, result2, result3, result4, result5, result6, result7, result8);
				return true;
			}
			if (!float.TryParse(array[8], NumberStyles.Float, invariantCulture, out var result9))
			{
				return false;
			}
			if (!float.TryParse(array[9], NumberStyles.Float, invariantCulture, out var result10))
			{
				return false;
			}
			if (!float.TryParse(array[10], NumberStyles.Float, invariantCulture, out var result11))
			{
				return false;
			}
			record = new GraveRecord(result, result2, result3, result4, result5, result6, result7, result8, result9, result10, result11);
			return true;
		}
	}
	public sealed class GraveSightings
	{
		private readonly HashSet<uint> _seen = new HashSet<uint>();

		private long _worldId;

		public int Count => _seen.Count;

		public bool EnterWorld(long worldId)
		{
			if (worldId == _worldId)
			{
				return false;
			}
			_worldId = worldId;
			_seen.Clear();
			return true;
		}

		public void Observe(uint zdoId)
		{
			_seen.Add(zdoId);
		}

		public bool HasSeen(uint zdoId)
		{
			return _seen.Contains(zdoId);
		}
	}
	public static class GraveStore
	{
		public const int DefaultPerWorld = 5;

		public const int DefaultTotal = 20;

		private const char LineSeparator = '\n';

		public static IReadOnlyList<GraveRecord> Parse(string stored)
		{
			List<GraveRecord> list = new List<GraveRecord>();
			if (string.IsNullOrEmpty(stored))
			{
				return list;
			}
			string[] array = stored.Split('\n');
			for (int i = 0; i < array.Length; i++)
			{
				if (GraveRecord.TryParse(array[i], out var record))
				{
					list.Add(record);
				}
			}
			return list;
		}

		public static IReadOnlyList<GraveRecord> ForWorld(string stored, long worldId)
		{
			List<GraveRecord> list = new List<GraveRecord>();
			foreach (GraveRecord item in Parse(stored))
			{
				if (item.WorldId == worldId)
				{
					list.Add(item);
				}
			}
			return list;
		}

		public static string Add(string stored, GraveRecord record, int perWorld, int total)
		{
			List<GraveRecord> list = new List<GraveRecord>(Parse(stored));
			list.Insert(0, record);
			int num = 0;
			int num2 = 0;
			while (num2 < list.Count)
			{
				if (list[num2].WorldId == record.WorldId && ++num > perWorld)
				{
					list.RemoveAt(num2);
				}
				else
				{
					num2++;
				}
			}
			while (list.Count > total)
			{
				list.RemoveAt(list.Count - 1);
			}
			return Format(list);
		}

		public static string Remove(string stored, long worldId, uint zdoId)
		{
			List<GraveRecord> list = new List<GraveRecord>();
			foreach (GraveRecord item in Parse(stored))
			{
				if (item.WorldId != worldId || item.ZdoId != zdoId)
				{
					list.Add(item);
				}
			}
			return Format(list);
		}

		private static string Format(IReadOnlyList<GraveRecord> records)
		{
			List<string> list = new List<string>(records.Count);
			foreach (GraveRecord record in records)
			{
				list.Add(record.Format());
			}
			return string.Join('\n'.ToString(), list);
		}
	}
	public static class RespawnFoods
	{
		public const string DefaultTable = "Meadows:Honey|Raspberry|MushroomYellow,BlackForest:CarrotSoup|QueensJam|Honey,Swamp:TurnipStew|Sausages|CarrotSoup,Mountain:Eyescream|OnionSoup|TurnipStew,Plains:BloodPudding|Bread|Eyescream,Mistlands:FishAndBread|MushroomOmelette|Salad,Ashlands:RoastedCrustPie|ScorchingMedley|SpicyMarmalade,DeepNorth:OatmealLingonberryJam|OatMilk|KaleChips";

		public static string Pick(string table, string tier, Func<string, bool> prefabExists)
		{
			if (prefabExists == null)
			{
				return null;
			}
			Dictionary<string, List<string>> dictionary = Parse(table);
			if (dictionary.Count == 0)
			{
				return null;
			}
			IReadOnlyList<string> tiers = WorldFrontier.Tiers;
			for (int num = IndexOf(tiers, tier); num >= 0; num--)
			{
				if (dictionary.TryGetValue(tiers[num], out var value))
				{
					foreach (string item in value)
					{
						if (prefabExists(item))
						{
							return item;
						}
					}
				}
			}
			return null;
		}

		private static int IndexOf(IReadOnlyList<string> tiers, string tier)
		{
			for (int i = 0; i < tiers.Count; i++)
			{
				if (string.Equals(tiers[i], tier, StringComparison.OrdinalIgnoreCase))
				{
					return i;
				}
			}
			return 0;
		}

		private static Dictionary<string, List<string>> Parse(string table)
		{
			Dictionary<string, List<string>> dictionary = new Dictionary<string, List<string>>(StringComparer.OrdinalIgnoreCase);
			if (string.IsNullOrWhiteSpace(table))
			{
				return dictionary;
			}
			string[] array = table.Split(',');
			for (int i = 0; i < array.Length; i++)
			{
				string[] array2 = array[i].Split(':');
				if (array2.Length != 2)
				{
					continue;
				}
				string text = array2[0].Trim();
				if (text.Length == 0)
				{
					continue;
				}
				List<string> list = new List<string>();
				string[] array3 = array2[1].Split('|');
				for (int j = 0; j < array3.Length; j++)
				{
					string text2 = array3[j].Trim();
					if (text2.Length > 0)
					{
						list.Add(text2);
					}
				}
				if (list.Count > 0)
				{
					dictionary[text] = list;
				}
			}
			return dictionary;
		}
	}
	public readonly struct MarkerPlacement
	{
		public bool Visible { get; }

		public float X { get; }

		public float Y { get; }

		public bool OnScreen { get; }

		public float AngleDegrees { get; }

		public static MarkerPlacement Hidden => new MarkerPlacement(visible: false, 0f, 0f, onScreen: false, 0f);

		public MarkerPlacement(bool visible, float x, float y, bool onScreen, float angleDegrees)
		{
			Visible = visible;
			X = x;
			Y = y;
			OnScreen = onScreen;
			AngleDegrees = angleDegrees;
		}
	}
	public static class ScreenMarker
	{
		public static MarkerPlacement Place(float screenX, float screenY, float screenZ, float screenWidth, float screenHeight, float margin)
		{
			if (screenWidth <= 0f || screenHeight <= 0f)
			{
				return MarkerPlacement.Hidden;
			}
			float num = screenWidth / 2f;
			float num2 = screenHeight / 2f;
			float num3 = screenX;
			float num4 = screenY;
			if (screenZ < 0f)
			{
				num3 = num - (screenX - num);
				num4 = num2 - (screenY - num2);
			}
			if (screenZ >= 0f && num3 >= 0f && num3 <= screenWidth && num4 >= 0f && num4 <= screenHeight)
			{
				return new MarkerPlacement(visible: true, num3, num4, onScreen: true, 0f);
			}
			float num5 = Math.Min(margin, num * 0.9f);
			float num6 = Math.Min(margin, num2 * 0.9f);
			float num7 = num3 - num;
			float num8 = num4 - num2;
			if (num7 == 0f && num8 == 0f)
			{
				num8 = 1f;
			}
			float val = ((num7 == 0f) ? float.MaxValue : ((num - num5) / Math.Abs(num7)));
			float val2 = ((num8 == 0f) ? float.MaxValue : ((num2 - num6) / Math.Abs(num8)));
			float num9 = Math.Min(val, val2);
			float num10 = (float)(Math.Atan2(num7, num8) * 180.0 / Math.PI);
			if (num10 < 0f)
			{
				num10 += 360f;
			}
			return new MarkerPlacement(visible: true, num + num7 * num9, num2 + num8 * num9, onScreen: false, num10);
		}
	}
}
namespace RossQoL.Core.Crafting
{
	public readonly struct TierChoice
	{
		public int Quality { get; }

		public int Available { get; }

		public TierChoice(int quality, int available)
		{
			Quality = quality;
			Available = available;
		}

		public bool Covers(int need)
		{
			return Available >= need;
		}
	}
	public static class CraftPayment
	{
		public static TierChoice ChooseTier(IReadOnlyList<int> heldByQuality, int need)
		{
			if (heldByQuality == null)
			{
				return new TierChoice(0, 0);
			}
			int quality = 0;
			int num = 0;
			for (int i = 0; i < heldByQuality.Count; i++)
			{
				int num2 = heldByQuality[i];
				if (num2 > num)
				{
					num = num2;
					quality = i;
				}
			}
			if (need > 0)
			{
				for (int j = 0; j < heldByQuality.Count; j++)
				{
					if (heldByQuality[j] >= need)
					{
						return new TierChoice(j, num);
					}
				}
			}
			return new TierChoice(quality, num);
		}

		public static int Owing(int owed, int paidFromPack)
		{
			if (owed <= 0)
			{
				return 0;
			}
			int num = ((paidFromPack > 0) ? paidFromPack : 0);
			int num2 = owed - num;
			if (num2 <= 0)
			{
				return 0;
			}
			return num2;
		}

		public static int Shortfall(int owed, int paidFromPack, int takenFromContainers)
		{
			int num = Owing(owed, paidFromPack);
			int num2 = ((takenFromContainers > 0) ? takenFromContainers : 0);
			int num3 = num - num2;
			if (num3 <= 0)
			{
				return 0;
			}
			return num3;
		}
	}
	public static class RecipeCategories
	{
		private static readonly string[] None = Array.Empty<string>();

		public static string[] WordsFor(string itemType)
		{
			switch (itemType)
			{
			case "Helmet":
				return new string[2] { "helmet", "armor" };
			case "Chest":
				return new string[2] { "chest", "armor" };
			case "Legs":
				return new string[2] { "legs", "armor" };
			case "Shoulder":
				return new string[2] { "cape", "armor" };
			case "Shield":
				return new string[1] { "shield" };
			case "Utility":
				return new string[1] { "utility" };
			case "Tool":
				return new string[1] { "tool" };
			case "Torch":
				return new string[1] { "torch" };
			case "Ammo":
			case "AmmoNonEquipable":
				return new string[1] { "ammo" };
			case "Consumable":
				return new string[1] { "food" };
			case "Material":
				return new string[1] { "material" };
			case "Trinket":
				return new string[1] { "trinket" };
			case "OneHandedWeapon":
			case "TwoHandedWeapon":
			case "TwoHandedWeaponLeft":
			case "Bow":
				return new string[1] { "weapon" };
			default:
				return None;
			}
		}

		public static bool HasSkillWord(string itemType)
		{
			switch (itemType)
			{
			case "OneHandedWeapon":
			case "TwoHandedWeapon":
			case "TwoHandedWeaponLeft":
			case "Bow":
			case "Tool":
				return true;
			default:
				return false;
			}
		}
	}
	public static class RecipeSearch
	{
		public static bool IsActive(string term)
		{
			return Normalize(term).Length > 0;
		}

		public static bool Matches(string displayName, string term)
		{
			string text = Normalize(term);
			if (text.Length == 0)
			{
				return true;
			}
			if (displayName == null)
			{
				return false;
			}
			return Normalize(displayName).IndexOf(text, StringComparison.Ordinal) >= 0;
		}

		public static bool Matches(string displayName, IEnumerable<string> categoryWords, string term)
		{
			if (Matches(displayName, term))
			{
				return true;
			}
			if (categoryWords == null)
			{
				return false;
			}
			string value = Normalize(term);
			foreach (string categoryWord in categoryWords)
			{
				if (categoryWord != null && Normalize(categoryWord).IndexOf(value, StringComparison.Ordinal) >= 0)
				{
					return true;
				}
			}
			return false;
		}

		private static string Normalize(string text)
		{
			if (string.IsNullOrEmpty(text))
			{
				return string.Empty;
			}
			StringBuilder stringBuilder = new StringBuilder(text.Length);
			foreach (char c in text)
			{
				if (!char.IsWhiteSpace(c))
				{
					stringBuilder.Append(char.ToLowerInvariant(c));
				}
			}
			return stringBuilder.ToString();
		}
	}
	public static class RequirementAmountFormat
	{
		public static string Format(int have, int need)
		{
			return have + "/" + need;
		}
	}
}
namespace RossQoL.Core.Combat
{
	public sealed class SecondPower
	{
		private float _cooldown;

		public string Power { get; private set; } = "";

		public bool HasPower => !string.IsNullOrEmpty(Power);

		public float Remaining
		{
			get
			{
				if (!(_cooldown > 0f))
				{
					return 0f;
				}
				return _cooldown;
			}
		}

		public bool IsReady => _cooldown <= 0f;

		public bool Set(string power)
		{
			power = power ?? "";
			if (power == Power)
			{
				return false;
			}
			Power = power;
			_cooldown = 0f;
			return true;
		}

		public bool Clear()
		{
			if (!HasPower)
			{
				return false;
			}
			Power = "";
			_cooldown = 0f;
			return true;
		}

		public void StartCooldown(float seconds)
		{
			if (seconds > 0f)
			{
				_cooldown = seconds;
			}
		}

		public void Tick(float dt)
		{
			if (!(dt <= 0f) && !(_cooldown <= 0f))
			{
				_cooldown -= dt;
				if (_cooldown < 0f)
				{
					_cooldown = 0f;
				}
			}
		}

		public string Serialize()
		{
			if (!HasPower)
			{
				return "";
			}
			if (!(Remaining > 0f))
			{
				return Power;
			}
			return Power + "|" + Remaining.ToString(CultureInfo.InvariantCulture);
		}

		public static SecondPower Parse(string data, Func<string, bool> isValid = null)
		{
			SecondPower secondPower = new SecondPower();
			if (string.IsNullOrEmpty(data))
			{
				return secondPower;
			}
			int num = data.IndexOf('|');
			string text = ((num < 0) ? data : data.Substring(0, num)).Trim();
			if (text.Length == 0)
			{
				return secondPower;
			}
			if (isValid != null && !isValid(text))
			{
				return secondPower;
			}
			secondPower.Power = text;
			if (num >= 0 && float.TryParse(data.Substring(num + 1).Trim(), NumberStyles.Float, CultureInfo.InvariantCulture, out var result) && result > 0f)
			{
				secondPower._cooldown = result;
			}
			return secondPower;
		}
	}
}