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 Microsoft.CodeAnalysis;

[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+15e702664b55bcc257f097082a96453b6d0fa5c6")]
[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.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 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";

		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" },
			{ "BlackMetalScrap", "defeated_goblinking" },
			{ "BlackMetal", "defeated_goblinking" }
		};

		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;
		}
	}
}
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 readonly struct TameCandidate
	{
		public Vec3 Position { get; }

		public bool IsTamed { get; }

		public bool IsFollowingPlayer { get; }

		public bool IsBusy { get; }

		public TameCandidate(Vec3 position, bool isTamed, bool isFollowingPlayer, bool isBusy)
		{
			Position = position;
			IsTamed = isTamed;
			IsFollowingPlayer = isFollowingPlayer;
			IsBusy = isBusy;
		}
	}
	public static class TameEligibility
	{
		public static bool Qualifies(TameCandidate candidate, Vec3 playerPosition, float radius)
		{
			if (radius <= 0f)
			{
				return false;
			}
			if (!candidate.IsTamed)
			{
				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 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.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 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";
		}
	}
}
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.Crafting
{
	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();
		}
	}
}