using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Text;
using System.Text.RegularExpressions;
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("ExtraPotions")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyCopyright("Copyright (C) 2026 expDARE (ExtraPotions Meadworks)")]
[assembly: AssemblyFileVersion("0.1.18.0")]
[assembly: AssemblyInformationalVersion("0.1.18+da1d6644b921fba451b3511c7b98b4c9770d446f")]
[assembly: AssemblyProduct("Hex.Core")]
[assembly: AssemblyTitle("Hex.Core")]
[assembly: AssemblyVersion("0.1.18.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

		public NullableAttribute(byte P_0)
		{
			NullableFlags = new byte[1] { P_0 };
		}

		public NullableAttribute(byte[] P_0)
		{
			NullableFlags = P_0;
		}
	}
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
	[CompilerGenerated]
	[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 ExtraPotions.Hex
{
	public static class HexActionKeys
	{
		public static IReadOnlyList<string> Powers { get; } = new string[8] { "GP_Eikthyr", "GP_TheElder", "GP_Bonemass", "GP_Moder", "GP_Yagluth", "GP_Queen", "GP_Ashlands", "GP_DeepNorth" };

		public static IReadOnlyList<string> Keys { get; } = new string[17]
		{
			"heal", "rested", "reveal", "poi", "estimatepoi", "seed", "reset", "reset_speeds", "spawn_protection", "GP_Eikthyr",
			"GP_TheElder", "GP_Bonemass", "GP_Moder", "GP_Yagluth", "GP_Queen", "GP_Ashlands", "GP_DeepNorth"
		};

		public static string Label(string key)
		{
			return key switch
			{
				"spawn_protection" => "spawn_protection_label", 
				"reset" => "map_reset", 
				"seed" => "seed_label", 
				"reset_speeds" => "speeds_reset_all", 
				"estimatepoi" => "poi_estimate", 
				"poi" => "poi_actual", 
				"reveal" => "map_reveal", 
				"rested" => "actions_rested", 
				"heal" => "actions_heal", 
				_ => "actions_power", 
			};
		}
	}
	public static class HexCatalog
	{
		public static IReadOnlyList<string> AgreedUnits { get; } = new string[26]
		{
			"A1", "A2", "A3", "A4", "A5", "A6", "A7", "A8", "B1", "B2",
			"B3", "C1", "C2", "C3", "C4", "D1", "E1", "E2", "F1", "F2",
			"F3", "G1", "G2", "G3", "G4", "G5"
		};

		public static IReadOnlyList<string> RuntimeKeys { get; } = new string[35]
		{
			"unlimited_stamina", "unlimited_eitr", "infinite_jumps", "walk_speed", "run_speed", "swim_speed", "jump_power", "moon_gravity", "disable_durability_loss", "no_carry_limit",
			"custom_carry_weight", "disable_food_degradation", "god_mode", "ghost_mode", "fly", "noclip", "freecam", "fly_speed", "mounted_speed", "keep_items",
			"keep_food", "keep_skills", "keep_status_effects", "achievements_despite_cheats", "clear_inventory_marks", "clear_container_marks", "clear_drop_marks", "local_time_minute", "local_time_freeze", "bouncy",
			"super_knockback", "party_hits", "player_size", "debug_mode", "esp"
		};

		public static float SpeedFactor(int percent)
		{
			return (float)Math.Min(300, Math.Max(10, percent)) / 100f;
		}

		public static float SizeFactor(int percent)
		{
			return (float)Math.Min(300, Math.Max(25, percent)) / 100f;
		}

		public static float JumpFactor(int percent)
		{
			return (float)Math.Min(500, Math.Max(25, percent)) / 100f;
		}

		public static float CarryCapacity(float native, bool noLimit, int custom)
		{
			if (!noLimit)
			{
				if (custom <= 0)
				{
					return native;
				}
				return Math.Min(99999, custom);
			}
			return float.PositiveInfinity;
		}
	}
	public readonly struct OwnedScale
	{
		public readonly float Before;

		public readonly float Applied;

		public OwnedScale(float before, float factor)
		{
			Before = before;
			Applied = before * factor;
		}

		public float Restore(float current)
		{
			if (current != Applied)
			{
				return current;
			}
			return Before;
		}
	}
	public static class HexCore
	{
		public const string PluginGuid = "com.meadworks.hex";

		public const string ProductName = "Hex";

		public const string ProductVersion = "0.1.18";

		public const string Family = "Mischief";

		public const string TokenNamespace = "hex";

		public const string SupportedGameVersion = "1.0.17";

		public const string TokenPrefix = "meadworks_hex_";

		public const string DataFolder = "Meadworks/hex";
	}
	public static class HexDebugView
	{
		public const float DayPerMouse = 0.005f;

		public const float FovMin = 0.5f;

		public const float FovMax = 165f;

		public static float Day(float fraction, float mouseY)
		{
			float num = (fraction + mouseY * 0.005f) % 1f;
			if (!(num < 0f))
			{
				return num;
			}
			return num + 1f;
		}

		public static float Fov(float fov, float mouseX)
		{
			return Math.Max(0.5f, Math.Min(165f, fov + mouseX));
		}
	}
	public sealed class HexHotkeyValues
	{
		private readonly Dictionary<string, object> selected = new Dictionary<string, object>(StringComparer.Ordinal);

		public void Remember(string key, object current, object safe)
		{
			if (current is int && !object.Equals(current, safe))
			{
				selected[key] = current;
			}
		}

		public bool Next(string key, object current, object safe, out object next)
		{
			Remember(key, current, safe);
			next = safe;
			if (current is bool flag)
			{
				next = !flag;
				return true;
			}
			if (!(current is int))
			{
				return false;
			}
			if (!object.Equals(current, safe))
			{
				return true;
			}
			return selected.TryGetValue(key, out next);
		}
	}
	public readonly struct HexKillReply
	{
		public int Targets { get; }

		public int Submitted { get; }

		public int Skipped { get; }

		public HexKillReply(int targets, int submitted, int skipped)
		{
			Targets = targets;
			Submitted = submitted;
			Skipped = skipped;
		}
	}
	public readonly struct HexAreaRequest
	{
		public float Radius { get; }

		public HexAreaRequest(float radius)
		{
			Radius = radius;
		}
	}
	public static class HexKillData
	{
		public const string OperationId = "meadworks.hex.debug_kill";

		public const string DropsOperationId = "meadworks.hex.debug_drops";

		public const string TameOperationId = "meadworks.hex.debug_tame";

		public const string EventOperationId = "meadworks.hex.debug_event";

		public const int MaxTargets = 512;

		public static readonly Version Version = new Version(1, 0);

		public static byte[] EncodeRequest(HexAreaRequest request)
		{
			if (!HexOwnerData.ValidRadius(request.Radius))
			{
				throw new ArgumentException("Invalid radius.");
			}
			using MemoryStream memoryStream = new MemoryStream();
			using BinaryWriter binaryWriter = new BinaryWriter(memoryStream);
			binaryWriter.Write((byte)2);
			binaryWriter.Write((byte)1);
			binaryWriter.Write(request.Radius);
			return memoryStream.ToArray();
		}

		public static HexAreaRequest DecodeRequest(byte[] bytes)
		{
			if (bytes == null || bytes.Length != 6 || bytes[0] != 2 || bytes[1] != 1)
			{
				throw new FormatException("Invalid kill request.");
			}
			using BinaryReader binaryReader = new BinaryReader(new MemoryStream(bytes, writable: false));
			binaryReader.ReadByte();
			binaryReader.ReadByte();
			float radius = binaryReader.ReadSingle();
			if (!HexOwnerData.ValidRadius(radius))
			{
				throw new FormatException("Invalid radius.");
			}
			return new HexAreaRequest(radius);
		}

		public static byte[] EncodeEvent(bool confirmed)
		{
			if (!confirmed)
			{
				throw new ArgumentException("Event confirmation required.");
			}
			return new byte[2] { 1, 1 };
		}

		public static bool DecodeEvent(byte[] bytes)
		{
			if (bytes == null || bytes.Length != 2 || bytes[0] != 1 || bytes[1] != 1)
			{
				throw new FormatException("Invalid event request.");
			}
			return true;
		}

		private static bool Valid(HexKillReply value)
		{
			if (value.Targets >= 0 && value.Targets <= 512 && value.Submitted >= 0 && value.Skipped >= 0 && value.Submitted <= value.Targets)
			{
				return value.Skipped == value.Targets - value.Submitted;
			}
			return false;
		}

		public static byte[] EncodeReply(HexKillReply value)
		{
			if (!Valid(value))
			{
				throw new ArgumentException("Invalid kill result.");
			}
			using MemoryStream memoryStream = new MemoryStream();
			using BinaryWriter binaryWriter = new BinaryWriter(memoryStream);
			binaryWriter.Write((byte)1);
			binaryWriter.Write(value.Targets);
			binaryWriter.Write(value.Submitted);
			binaryWriter.Write(value.Skipped);
			return memoryStream.ToArray();
		}

		public static HexKillReply DecodeReply(byte[] bytes)
		{
			if (bytes == null || bytes.Length != 13 || bytes[0] != 1)
			{
				throw new FormatException("Invalid kill result.");
			}
			using BinaryReader binaryReader = new BinaryReader(new MemoryStream(bytes, writable: false));
			binaryReader.ReadByte();
			HexKillReply hexKillReply = new HexKillReply(binaryReader.ReadInt32(), binaryReader.ReadInt32(), binaryReader.ReadInt32());
			if (!Valid(hexKillReply))
			{
				throw new FormatException("Invalid kill counts.");
			}
			return hexKillReply;
		}
	}
	public static class HexMenu
	{
		public const float ValueX = 380f;

		public const float RowEnd = 708f;

		public static IReadOnlyList<string> Tabs { get; } = new string[7] { "cheats", "movement", "skills", "spawn", "map", "debug", "presets" };

		public static IReadOnlyList<string> Speeds { get; } = new string[5] { "walk_speed", "run_speed", "swim_speed", "fly_speed", "mounted_speed" };

		public static IReadOnlyDictionary<string, string[]> Preferences { get; } = new Dictionary<string, string[]>
		{
			["cheats"] = new string[17]
			{
				"god_mode", "ghost_mode", "fly", "noclip", "freecam", "unlimited_stamina", "unlimited_eitr", "infinite_jumps", "disable_durability_loss", "disable_food_degradation",
				"no_carry_limit", "custom_carry_weight", "keep_items", "keep_food", "keep_skills", "keep_status_effects", "quick_actions"
			},
			["movement"] = new string[11]
			{
				"moon_gravity", "bouncy", "super_knockback", "party_hits", "jump_power", "player_size", "walk_speed", "run_speed", "swim_speed", "fly_speed",
				"mounted_speed"
			},
			["skills"] = new string[1] { "skill_editor" },
			["spawn"] = new string[0],
			["map"] = new string[1] { "map_tools" },
			["debug"] = new string[5] { "debug_tools", "debug_mode", "esp", "local_time_minute", "local_time_freeze" },
			["presets"] = new string[0]
		};

		public static IReadOnlyList<string> AlmanacOnly { get; } = new string[4] { "achievements_despite_cheats", "clear_inventory_marks", "clear_container_marks", "clear_drop_marks" };

		public static IReadOnlyList<(string Id, int Minute)> TimePresets { get; } = new(string, int)[4]
		{
			("midnight", 0),
			("sunrise", 360),
			("noon", 720),
			("sunset", 1080)
		};

		public static (float X, float Width) ResetSpan(float captionWidth)
		{
			float num = Math.Min(150f, Math.Max(68f, captionWidth + 18f));
			return (X: 708f - num, Width: num);
		}

		public static float ValueWidth(float preferred, float resetX)
		{
			return Math.Max(120f, Math.Min(preferred, resetX - 10f - 380f));
		}
	}
	public enum HexOwnerAction : byte
	{
		Kill = 1,
		Drops,
		Tame
	}
	public readonly struct HexTargetId : IEquatable<HexTargetId>
	{
		public long User { get; }

		public uint Id { get; }

		public HexTargetId(long user, uint id)
		{
			User = user;
			Id = id;
		}

		public bool Equals(HexTargetId other)
		{
			if (User == other.User)
			{
				return Id == other.Id;
			}
			return false;
		}

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

		public override int GetHashCode()
		{
			return (User.GetHashCode() * 397) ^ (int)Id;
		}

		public override string ToString()
		{
			return User + ":" + Id;
		}
	}
	public sealed class HexOwnerCommand
	{
		public HexOwnerAction Action { get; }

		public float X { get; }

		public float Y { get; }

		public float Z { get; }

		public float Radius { get; }

		public IReadOnlyList<HexTargetId> Targets { get; }

		public HexOwnerCommand(HexOwnerAction action, float x, float y, float z, float radius, IReadOnlyList<HexTargetId> targets)
		{
			Action = action;
			X = x;
			Y = y;
			Z = z;
			Radius = radius;
			Targets = targets;
		}
	}
	public readonly struct HexOwnerReply
	{
		public int Applied { get; }

		public int Skipped { get; }

		public HexOwnerReply(int applied, int skipped)
		{
			Applied = applied;
			Skipped = skipped;
		}
	}
	public static class HexOwnerData
	{
		public const string CommandId = "meadworks.hex.debug_owner";

		public const int MaxBatch = 64;

		public const float MinRadius = 5f;

		public const float MaxRadius = 1000f;

		public static readonly Version Version = new Version(2, 0);

		private static bool Finite(float value)
		{
			if (!float.IsNaN(value))
			{
				return !float.IsInfinity(value);
			}
			return false;
		}

		private static bool Defined(HexOwnerAction action)
		{
			if (action != HexOwnerAction.Kill && action != HexOwnerAction.Drops)
			{
				return action == HexOwnerAction.Tame;
			}
			return true;
		}

		public static bool ValidRadius(float radius)
		{
			if (Finite(radius) && radius >= 5f)
			{
				return radius <= 1000f;
			}
			return false;
		}

		public static bool SkipCreature(HexOwnerAction action, bool player, bool tamed)
		{
			if (action != HexOwnerAction.Drops)
			{
				return player || tamed;
			}
			return false;
		}

		public static bool Within(float cx, float cy, float cz, float x, float y, float z, float radius)
		{
			if (!Finite(cx) || !Finite(cy) || !Finite(cz) || !Finite(x) || !Finite(y) || !Finite(z))
			{
				return false;
			}
			double num = x - cx;
			double num2 = y - cy;
			double num3 = z - cz;
			return num * num + num2 * num2 + num3 * num3 <= (double)radius * (double)radius;
		}

		public static byte[] Encode(HexOwnerCommand command)
		{
			if (command == null || !Defined(command.Action) || !Finite(command.X) || !Finite(command.Y) || !Finite(command.Z) || !ValidRadius(command.Radius) || command.Targets == null || command.Targets.Count < 1 || command.Targets.Count > 64 || command.Targets.Distinct().Count() != command.Targets.Count)
			{
				throw new ArgumentException("Invalid owner command.");
			}
			using MemoryStream memoryStream = new MemoryStream();
			using BinaryWriter binaryWriter = new BinaryWriter(memoryStream);
			binaryWriter.Write((byte)2);
			binaryWriter.Write((byte)command.Action);
			binaryWriter.Write(command.X);
			binaryWriter.Write(command.Y);
			binaryWriter.Write(command.Z);
			binaryWriter.Write(command.Radius);
			binaryWriter.Write((ushort)command.Targets.Count);
			foreach (HexTargetId target in command.Targets)
			{
				binaryWriter.Write(target.User);
				binaryWriter.Write(target.Id);
			}
			return memoryStream.ToArray();
		}

		public static HexOwnerCommand Decode(byte[] bytes)
		{
			if (bytes == null || bytes.Length < 20 || bytes[0] != 2 || !Defined((HexOwnerAction)bytes[1]))
			{
				throw new FormatException("Invalid owner command.");
			}
			using BinaryReader binaryReader = new BinaryReader(new MemoryStream(bytes, writable: false));
			binaryReader.ReadByte();
			HexOwnerAction action = (HexOwnerAction)binaryReader.ReadByte();
			float num = binaryReader.ReadSingle();
			float num2 = binaryReader.ReadSingle();
			float num3 = binaryReader.ReadSingle();
			float radius = binaryReader.ReadSingle();
			int num4 = binaryReader.ReadUInt16();
			if (!Finite(num) || !Finite(num2) || !Finite(num3) || !ValidRadius(radius) || num4 < 1 || num4 > 64 || bytes.Length != 20 + num4 * 12)
			{
				throw new FormatException("Invalid owner command.");
			}
			List<HexTargetId> list = new List<HexTargetId>(num4);
			for (int i = 0; i < num4; i++)
			{
				list.Add(new HexTargetId(binaryReader.ReadInt64(), binaryReader.ReadUInt32()));
			}
			if (list.Distinct().Count() != num4)
			{
				throw new FormatException("Repeated owner target.");
			}
			return new HexOwnerCommand(action, num, num2, num3, radius, list);
		}

		private static bool Valid(int applied, int skipped)
		{
			if (applied >= 0 && skipped >= 0 && applied <= 64 && skipped <= 64 && applied + skipped >= 1)
			{
				return applied + skipped <= 64;
			}
			return false;
		}

		public static byte[] EncodeReply(HexOwnerReply reply)
		{
			if (!Valid(reply.Applied, reply.Skipped))
			{
				throw new ArgumentException("Invalid owner reply.");
			}
			using MemoryStream memoryStream = new MemoryStream();
			using BinaryWriter binaryWriter = new BinaryWriter(memoryStream);
			binaryWriter.Write((byte)1);
			binaryWriter.Write(reply.Applied);
			binaryWriter.Write(reply.Skipped);
			return memoryStream.ToArray();
		}

		public static HexOwnerReply DecodeReply(byte[] bytes)
		{
			if (bytes == null || bytes.Length != 9 || bytes[0] != 1)
			{
				throw new FormatException("Invalid owner reply.");
			}
			using BinaryReader binaryReader = new BinaryReader(new MemoryStream(bytes, writable: false));
			binaryReader.ReadByte();
			int applied = binaryReader.ReadInt32();
			int skipped = binaryReader.ReadInt32();
			if (!Valid(applied, skipped))
			{
				throw new FormatException("Invalid owner counts.");
			}
			return new HexOwnerReply(applied, skipped);
		}
	}
	public readonly struct HexOwnedTarget
	{
		public long Owner { get; }

		public HexTargetId Id { get; }

		public HexOwnedTarget(long owner, HexTargetId id)
		{
			Owner = owner;
			Id = id;
		}
	}
	public sealed class HexOwnerBatch
	{
		public long Owner { get; }

		public IReadOnlyList<HexTargetId> Ids { get; }

		public HexOwnerBatch(long owner, IReadOnlyList<HexTargetId> ids)
		{
			Owner = owner;
			Ids = ids;
		}
	}
	public sealed class HexOwnerPlan
	{
		public IReadOnlyList<HexOwnerBatch> Batches { get; }

		public int Targets { get; }

		public int Unowned { get; }

		public bool OverLimit { get; }

		internal HexOwnerPlan(IReadOnlyList<HexOwnerBatch> batches, int targets, int unowned, bool overLimit)
		{
			Batches = batches;
			Targets = targets;
			Unowned = unowned;
			OverLimit = overLimit;
		}
	}
	public static class HexOwnerPlanner
	{
		public static HexOwnerPlan Plan(IEnumerable<HexOwnedTarget> targets, int maxTargets, int batchSize)
		{
			if (maxTargets < 1)
			{
				throw new ArgumentOutOfRangeException("maxTargets");
			}
			if (batchSize < 1)
			{
				throw new ArgumentOutOfRangeException("batchSize");
			}
			HashSet<HexTargetId> hashSet = new HashSet<HexTargetId>();
			List<long> list = new List<long>();
			Dictionary<long, List<HexTargetId>> dictionary = new Dictionary<long, List<HexTargetId>>();
			int num = 0;
			int num2 = 0;
			foreach (HexOwnedTarget target in targets)
			{
				if (!hashSet.Add(target.Id))
				{
					continue;
				}
				if (target.Owner == 0L)
				{
					num++;
					continue;
				}
				num2++;
				if (!dictionary.TryGetValue(target.Owner, out var value))
				{
					value = new List<HexTargetId>();
					dictionary.Add(target.Owner, value);
					list.Add(target.Owner);
				}
				value.Add(target.Id);
			}
			if (num2 > maxTargets)
			{
				return new HexOwnerPlan(Array.Empty<HexOwnerBatch>(), num2, num, overLimit: true);
			}
			List<HexOwnerBatch> list2 = new List<HexOwnerBatch>();
			foreach (long item in list)
			{
				for (int i = 0; i < dictionary[item].Count; i += batchSize)
				{
					list2.Add(new HexOwnerBatch(item, dictionary[item].Skip(i).Take(batchSize).ToArray()));
				}
			}
			return new HexOwnerPlan(list2, num2, num, overLimit: false);
		}
	}
	public enum HexBatchState
	{
		Applied,
		Refused,
		Unknown
	}
	public sealed class HexOwnerTally
	{
		private readonly int targets;

		private int submitted;

		private int recorded;

		public bool Uncertain { get; private set; }

		public HexKillReply Reply
		{
			get
			{
				if (!Uncertain)
				{
					return new HexKillReply(targets, submitted, targets - submitted);
				}
				throw new InvalidOperationException("Owner outcome uncertain.");
			}
		}

		public HexOwnerTally(int targets)
		{
			if (targets < 0)
			{
				throw new ArgumentOutOfRangeException("targets");
			}
			this.targets = targets;
		}

		public void Record(int batchSize, HexBatchState state, HexOwnerReply reply)
		{
			recorded += batchSize;
			if (recorded > targets || batchSize < 1)
			{
				Uncertain = true;
				return;
			}
			switch (state)
			{
			case HexBatchState.Refused:
				return;
			case HexBatchState.Unknown:
				Uncertain = true;
				return;
			}
			if (reply.Applied < 0 || reply.Skipped < 0 || reply.Applied + reply.Skipped != batchSize)
			{
				Uncertain = true;
			}
			else
			{
				submitted += reply.Applied;
			}
		}
	}
	public static class HexPoiRows
	{
		public const string CapabilityId = "meadworks.thing.poi";

		public static readonly Version Version = new Version(1, 0);

		public const int Maximum = 512;

		private static readonly Dictionary<string, string> names = new Dictionary<string, string>(StringComparer.Ordinal)
		{
			["Eikthyrnir"] = "$enemy_eikthyr",
			["GDKing"] = "$enemy_gdking",
			["Bonemass"] = "$enemy_bonemass",
			["Dragonqueen"] = "$enemy_dragon",
			["GoblinKing"] = "$enemy_goblinking",
			["Mistlands_DvergrBossEntrance1"] = "$enemy_seekerqueen",
			["FaderLocation"] = "$enemy_fader",
			["DN_Bossroom"] = "$enemy_frozenking",
			["Vendor_BlackForest"] = "$npc_haldor",
			["Hildir_camp"] = "$npc_hildir",
			["BogWitch_Camp"] = "$npc_bogwitch"
		};

		public static bool Trader(string name)
		{
			if (!(name == "Vendor_BlackForest") && !(name == "Hildir_camp"))
			{
				return name == "BogWitch_Camp";
			}
			return true;
		}

		public static string Token(string name)
		{
			if (!names.TryGetValue(name, out string value))
			{
				return name;
			}
			return value;
		}

		private static bool Coordinate(float value)
		{
			if (!float.IsNaN(value) && !float.IsInfinity(value))
			{
				return Math.Abs(value) <= 20000f;
			}
			return false;
		}

		public static IReadOnlyList<Tuple<string, float, float, float, bool>> Select(IEnumerable<Tuple<string, float, float, float, bool>> source)
		{
			List<Tuple<string, float, float, float, bool>> list = new List<Tuple<string, float, float, float, bool>>();
			foreach (Tuple<string, float, float, float, bool> item in source)
			{
				if (item != null && names.ContainsKey(item.Item1 ?? "") && Coordinate(item.Item2) && Coordinate(item.Item3) && Coordinate(item.Item4))
				{
					list.Add(item);
					if (list.Count > 512)
					{
						throw new InvalidOperationException("PoiLimit");
					}
				}
			}
			HashSet<string> confirmed = new HashSet<string>(from row in list
				where Trader(row.Item1) && row.Item5
				select row.Item1, StringComparer.Ordinal);
			return Array.AsReadOnly(list.Where((Tuple<string, float, float, float, bool> row) => !Trader(row.Item1) || row.Item5 || !confirmed.Contains(row.Item1)).Distinct().ToArray());
		}
	}
	public static class HexSourceImport
	{
		public const string VatFile = "com.icecub.valheimadmintool.cfg";

		public const string VatPresetFile = "com.icecub.valheimadmintool.cheats.cfg";

		public const string AsFile = "liveriadevs.valheim.achievementsync.cfg";

		public static IReadOnlyDictionary<string, string> ToggleKeys { get; } = new Dictionary<string, string>(StringComparer.Ordinal)
		{
			["GodMode"] = "god_mode",
			["DebugMode"] = "debug_mode",
			["UnlimitedStamina"] = "unlimited_stamina",
			["UnlimitedEitr"] = "unlimited_eitr",
			["FlyMode"] = "fly",
			["InfiniteJumps"] = "infinite_jumps",
			["NoClipMode"] = "noclip",
			["FreeCamMode"] = "freecam",
			["GhostMode"] = "ghost_mode",
			["NoCarryLimit"] = "no_carry_limit",
			["DisableFoodDegradation"] = "disable_food_degradation",
			["DisableDurabilityLoss"] = "disable_durability_loss",
			["DisableItemLoss"] = "keep_items",
			["DisableFoodLoss"] = "keep_food",
			["DisableStatusLoss"] = "keep_status_effects",
			["DisableSkillLoss"] = "keep_skills",
			["MoonGravity"] = "moon_gravity",
			["SuperKnockback"] = "super_knockback",
			["BouncyMode"] = "bouncy",
			["PartyHits"] = "party_hits"
		};

		public static IReadOnlyDictionary<string, string> Owners { get; } = new Dictionary<string, string>(StringComparer.Ordinal)
		{
			["NoBuildCost"] = "Timber",
			["BuildEverywhere"] = "Timber",
			["NoStructuralDamage"] = "Timber",
			["MapTeleport"] = "Wayfarer",
			["UnrestrictedPortals"] = "Threshold",
			["ForgeAlwaysSucceed"] = "Inscribe",
			["InstantCrafting"] = "Kindle",
			["WindInBack"] = "Keel",
			["ShipSpeed"] = "Keel",
			["WardOverride"] = "Thing",
			["RemoveDrops"] = "Thing"
		};

		public static IReadOnlyDictionary<string, string> ActionKeys { get; } = new Dictionary<string, string>(StringComparer.Ordinal)
		{
			["QuickHeal"] = "heal",
			["Rested"] = "rested",
			["ExploreMap"] = "reveal",
			["RevealPoi"] = "poi",
			["ShowWorldSeed"] = "seed",
			["ResetMap"] = "reset",
			["BossPowerEikthyr"] = "GP_Eikthyr",
			["BossPowerElder"] = "GP_TheElder",
			["BossPowerBonemass"] = "GP_Bonemass",
			["BossPowerModer"] = "GP_Moder",
			["BossPowerYagluth"] = "GP_Yagluth",
			["BossPowerQueen"] = "GP_Queen",
			["BossPowerFader"] = "GP_Ashlands"
		};

		public static IReadOnlyDictionary<string, string> AchievementKeys { get; } = new Dictionary<string, string>(StringComparer.Ordinal)
		{
			["EnableAchievements"] = "achievements_despite_cheats",
			["ClearItemCheatFlags"] = "clear_inventory_marks",
			["ClearContainerCheatFlags"] = "clear_container_marks",
			["ClearWorldDropCheatFlags"] = "clear_drop_marks"
		};

		public static string? Target(string source, string sectionKey)
		{
			if (source == "vat")
			{
				if (sectionKey == "General.Toggle menu")
				{
					return "menu";
				}
				if (sectionKey.StartsWith("Hotkeys.", StringComparison.Ordinal))
				{
					if (ToggleKeys.TryGetValue(sectionKey.Substring(8), out string value))
					{
						return "hotkey:" + value;
					}
					if (ActionKeys.TryGetValue(sectionKey.Substring(8), out string value2))
					{
						return "action:" + value2;
					}
				}
			}
			if (source == "as" && sectionKey.StartsWith("General.", StringComparison.Ordinal) && AchievementKeys.TryGetValue(sectionKey.Substring(8), out string value3))
			{
				return "preference:" + value3;
			}
			if (source == "as-guard" && (sectionKey == "General.SyncPastStats" || sectionKey == "General.ResyncKey"))
			{
				return "Achievements." + sectionKey.Substring(8);
			}
			return null;
		}

		public static string? Referral(string sectionKey)
		{
			if (sectionKey.StartsWith("Automatic resets.", StringComparison.Ordinal))
			{
				return "Delve";
			}
			if (!sectionKey.StartsWith("Hotkeys.", StringComparison.Ordinal) || !Owners.TryGetValue(sectionKey.Substring(8), out string value))
			{
				return null;
			}
			return value;
		}

		public static string? PresetKey(string sectionKey)
		{
			int num = sectionKey.LastIndexOf('.');
			string text = ((num >= 0) ? sectionKey.Substring(num + 1) : sectionKey);
			if (ToggleKeys.TryGetValue(text, out string value))
			{
				return value;
			}
			foreach (string runtimeKey in HexCatalog.RuntimeKeys)
			{
				if (runtimeKey == text)
				{
					return runtimeKey;
				}
			}
			return null;
		}
	}
	public enum HexSpawnKind : byte
	{
		Item = 1,
		Creature
	}
	public sealed class HexSpawnRequest
	{
		public HexSpawnKind Kind { get; }

		public string Prefab { get; }

		public int Amount { get; }

		public int Level { get; }

		public bool Tamed { get; }

		public bool Inventory { get; }

		public HexSpawnRequest(HexSpawnKind kind, string prefab, int amount, int level, bool tamed, bool inventory)
		{
			Kind = kind;
			Prefab = prefab;
			Amount = amount;
			Level = level;
			Tamed = tamed;
			Inventory = inventory;
		}
	}
	public sealed class HexSpawnReply
	{
		public string Receipt { get; }

		public int Created { get; }

		public bool Partial { get; }

		public HexSpawnReply(string receipt, int created, bool partial)
		{
			Receipt = receipt;
			Created = created;
			Partial = partial;
		}
	}
	public static class HexSpawnData
	{
		public const string OperationId = "meadworks.hex.spawn";

		public const string AuditCapability = "meadworks.thing.hex_spawn_audit";

		public static readonly Version Version = new Version(1, 0);

		public const int MaxAmount = 9999;

		public const int MaxCreatureLevel = 100;

		private static readonly Regex Markup = new Regex("</?(?:color|b|i|u|s|size|material|quad|sprite|link|mark|align|alpha|font|style|rotate|sup|sub|nobr|noparse|cspace|mspace|pos|space|indent|margin|line-height|line-indent|lowercase|uppercase|smallcaps|voffset|width|gradient|page)(?:[=\\s][^<>]*)?>", RegexOptions.IgnoreCase | RegexOptions.Compiled | RegexOptions.CultureInvariant);

		private static readonly Regex Unresolved = new Regex("^(?:\\$[A-Za-z0-9_.]+|\\[[A-Za-z0-9_.]+\\])$", RegexOptions.Compiled | RegexOptions.CultureInvariant);

		public static bool PrefabValid(string prefab)
		{
			if (!string.IsNullOrWhiteSpace(prefab) && prefab.Length <= 160)
			{
				return prefab.All((char c) => !char.IsControl(c));
			}
			return false;
		}

		public static bool Valid(HexSpawnRequest request)
		{
			if (request != null && Enum.IsDefined(typeof(HexSpawnKind), request.Kind) && PrefabValid(request.Prefab) && request.Amount >= 1 && request.Amount <= 9999 && request.Level >= 1)
			{
				if (request.Kind != HexSpawnKind.Item)
				{
					if (request.Level <= 100)
					{
						return !request.Inventory;
					}
					return false;
				}
				return !request.Tamed;
			}
			return false;
		}

		public static bool Supported(HexSpawnRequest request, int itemMaxQuality, bool tameable)
		{
			if (Valid(request))
			{
				if (request.Kind != HexSpawnKind.Item)
				{
					return !request.Tamed || tameable;
				}
				return request.Level <= itemMaxQuality;
			}
			return false;
		}

		private static bool Flag(BinaryReader reader)
		{
			byte b = reader.ReadByte();
			if (b > 1)
			{
				throw new FormatException("Invalid spawn flag.");
			}
			return b == 1;
		}

		private static BinaryReader Reader(byte[] bytes, int maximum)
		{
			if (bytes == null || bytes.Length < 2 || bytes.Length > maximum)
			{
				throw new FormatException("Invalid spawn payload length.");
			}
			BinaryReader binaryReader = new BinaryReader(new MemoryStream(bytes, writable: false), new UTF8Encoding(encoderShouldEmitUTF8Identifier: false, throwOnInvalidBytes: true));
			if (binaryReader.ReadByte() != 1)
			{
				binaryReader.Dispose();
				throw new FormatException("Invalid spawn format.");
			}
			return binaryReader;
		}

		public static byte[] Encode(HexSpawnRequest request)
		{
			if (!Valid(request))
			{
				throw new ArgumentException("Invalid spawn request.");
			}
			using MemoryStream memoryStream = new MemoryStream();
			using BinaryWriter binaryWriter = new BinaryWriter(memoryStream, Encoding.UTF8, leaveOpen: true);
			binaryWriter.Write((byte)1);
			binaryWriter.Write((byte)request.Kind);
			binaryWriter.Write(request.Prefab);
			binaryWriter.Write(request.Amount);
			binaryWriter.Write(request.Level);
			binaryWriter.Write(request.Tamed);
			binaryWriter.Write(request.Inventory);
			return memoryStream.ToArray();
		}

		public static HexSpawnRequest Decode(byte[] bytes)
		{
			using BinaryReader binaryReader = Reader(bytes, 1024);
			HexSpawnRequest hexSpawnRequest = new HexSpawnRequest((HexSpawnKind)binaryReader.ReadByte(), binaryReader.ReadString(), binaryReader.ReadInt32(), binaryReader.ReadInt32(), Flag(binaryReader), Flag(binaryReader));
			if (!Valid(hexSpawnRequest) || binaryReader.BaseStream.Position != binaryReader.BaseStream.Length)
			{
				throw new FormatException("Invalid spawn request.");
			}
			return hexSpawnRequest;
		}

		private static bool Valid(HexSpawnReply reply)
		{
			if (reply != null && Guid.TryParseExact(reply.Receipt, "N", out var _) && reply.Created >= 0)
			{
				return reply.Created <= 9999;
			}
			return false;
		}

		public static byte[] Encode(HexSpawnReply reply)
		{
			if (!Valid(reply))
			{
				throw new ArgumentException("Invalid spawn reply.");
			}
			using MemoryStream memoryStream = new MemoryStream();
			using BinaryWriter binaryWriter = new BinaryWriter(memoryStream, Encoding.UTF8, leaveOpen: true);
			binaryWriter.Write((byte)1);
			binaryWriter.Write(reply.Receipt);
			binaryWriter.Write(reply.Created);
			binaryWriter.Write(reply.Partial);
			return memoryStream.ToArray();
		}

		public static HexSpawnReply DecodeReply(byte[] bytes)
		{
			using BinaryReader binaryReader = Reader(bytes, 128);
			HexSpawnReply hexSpawnReply = new HexSpawnReply(binaryReader.ReadString(), binaryReader.ReadInt32(), Flag(binaryReader));
			if (!Valid(hexSpawnReply) || binaryReader.BaseStream.Position != binaryReader.BaseStream.Length)
			{
				throw new FormatException("Invalid spawn reply.");
			}
			return hexSpawnReply;
		}

		public static string DisplayName(string? localized, string prefab)
		{
			string text = Markup.Replace(localized ?? "", "");
			StringBuilder stringBuilder = new StringBuilder(text.Length);
			string text2 = text;
			foreach (char c in text2)
			{
				stringBuilder.Append((char.IsControl(c) || CharUnicodeInfo.GetUnicodeCategory(c) == UnicodeCategory.Format) ? ' ' : c);
			}
			string text3 = Regex.Replace(stringBuilder.ToString(), "\\s+", " ").Trim();
			if (text3.Length != 0 && !Unresolved.IsMatch(text3))
			{
				return text3;
			}
			return prefab;
		}

		public static string Fold(string value)
		{
			StringBuilder stringBuilder = new StringBuilder();
			string text = (value ?? "").Normalize(NormalizationForm.FormD);
			foreach (char c in text)
			{
				if (CharUnicodeInfo.GetUnicodeCategory(c) != UnicodeCategory.NonSpacingMark && !char.IsWhiteSpace(c) && c != '_' && c != '-')
				{
					stringBuilder.Append(char.ToUpperInvariant(c));
				}
			}
			return stringBuilder.ToString().Normalize(NormalizationForm.FormC);
		}
	}
	public static class HexToolAccess
	{
		public static bool Allows(bool fullAdmin, bool granted, bool mischiefAllowed, bool refusedBecauseNotAdmin, bool adminRequired)
		{
			if (adminRequired && !fullAdmin && !granted)
			{
				return false;
			}
			if (mischiefAllowed)
			{
				return true;
			}
			return granted && refusedBecauseNotAdmin;
		}
	}
	public sealed class LocalClock
	{
		private int selected = -1;

		private bool frozen;

		private float offset;

		public void Reset()
		{
			selected = -1;
			offset = 0f;
		}

		public float Resolve(float native, int minute, bool freeze)
		{
			if (minute < 0 || minute > 1439 || float.IsNaN(native) || float.IsInfinity(native))
			{
				Reset();
				return native;
			}
			float num = (float)minute / 1440f;
			if (selected != minute || frozen != freeze)
			{
				selected = minute;
				frozen = freeze;
				offset = num - native;
			}
			float num2 = (freeze ? num : (native + offset));
			return num2 - (float)Math.Floor(num2);
		}
	}
	public static class SpawnProtectionGeometry
	{
		public readonly struct Point
		{
			public double X { get; }

			public double Z { get; }

			public Point(double x, double z)
			{
				X = x;
				Z = z;
			}
		}

		public readonly struct Circle
		{
			public double X { get; }

			public double Z { get; }

			public double Radius { get; }

			public int Segments { get; }

			public double InnerRadius => Radius * Math.Cos(Math.PI / (double)Segments);

			public Circle(double x, double z, double radius)
			{
				if (!Finite(x) || !Finite(z) || !Finite(radius) || radius <= 0.0 || radius > 1024.0)
				{
					throw new ArgumentOutOfRangeException("radius");
				}
				X = x;
				Z = z;
				Radius = radius;
				Segments = Math.Max(12, (int)Math.Ceiling(Math.PI / Math.Acos(1.0 - Math.Min(0.005, radius) / radius)));
			}
		}

		public sealed class Region
		{
			public IReadOnlyList<Point> Points { get; }

			public bool Covered { get; }

			internal Region(List<Point> points, bool covered)
			{
				Points = points;
				Covered = covered;
			}
		}

		public const double ChordError = 0.005;

		private const double Epsilon = 1E-09;

		private const int MaximumRegions = 512;

		public static IReadOnlyList<Region> Partition(double x, double z, double size, IReadOnlyList<Circle> circles, Circle? extent = null, bool covered = false)
		{
			if (!Finite(x) || !Finite(z) || !Finite(size) || size <= 0.0)
			{
				throw new ArgumentOutOfRangeException("size");
			}
			return Partition(new List<Point>
			{
				new Point(x, z),
				new Point(x + size, z),
				new Point(x + size, z + size),
				new Point(x, z + size)
			}, circles, extent, covered);
		}

		public static IReadOnlyList<Region> PartitionTriangle(Point a, Point b, Point c, IReadOnlyList<Circle> circles, Circle? extent = null, bool covered = false)
		{
			double num = Side(c, a, b);
			if (!Finite(a.X) || !Finite(a.Z) || !Finite(b.X) || !Finite(b.Z) || !Finite(c.X) || !Finite(c.Z) || Math.Abs(num) <= 1E-09)
			{
				throw new ArgumentOutOfRangeException("c");
			}
			return Partition((num > 0.0) ? new List<Point> { a, b, c } : new List<Point> { a, c, b }, circles, extent, covered);
		}

		public static double TriangleHeight(Point point, Point a, double heightA, Point b, double heightB, Point c, double heightC)
		{
			double num = Side(c, a, b);
			if (Math.Abs(num) <= 1E-09)
			{
				throw new ArgumentOutOfRangeException("c");
			}
			double num2 = Side(point, b, c) / num;
			double num3 = Side(point, c, a) / num;
			return num2 * heightA + num3 * heightB + (1.0 - num2 - num3) * heightC;
		}

		private static IReadOnlyList<Region> Partition(List<Point> cell, IReadOnlyList<Circle> circles, Circle? extent, bool covered)
		{
			if (circles == null || circles.Count > 512)
			{
				throw new ArgumentOutOfRangeException("circles");
			}
			if (extent.HasValue)
			{
				cell = Intersect(cell, extent.Value);
			}
			List<Region> list = new List<Region>();
			if (covered)
			{
				if (Valid(cell))
				{
					list.Add(new Region(cell, covered: true));
				}
				return list;
			}
			List<List<Point>> list2 = new List<List<Point>>();
			if (Valid(cell))
			{
				list2.Add(cell);
			}
			foreach (Circle circle in circles)
			{
				List<List<Point>> list3 = new List<List<Point>>();
				foreach (List<Point> item in list2)
				{
					if (Outside(item, circle))
					{
						list3.Add(item);
						continue;
					}
					if (Inside(item, circle))
					{
						list.Add(new Region(item, covered: true));
						continue;
					}
					List<Point> list4 = item;
					for (int i = 0; i < circle.Segments; i++)
					{
						if (!Valid(list4))
						{
							break;
						}
						Edge(circle, i, out var a, out var b);
						List<Point> list5 = Clip(list4, a, b, inside: false);
						if (Valid(list5))
						{
							list3.Add(list5);
						}
						list4 = Clip(list4, a, b, inside: true);
						if (list3.Count + list.Count > 512)
						{
							throw new InvalidOperationException("Protection geometry limit");
						}
					}
					if (Valid(list4))
					{
						list.Add(new Region(list4, covered: true));
					}
				}
				list2 = list3;
				if (list2.Count == 0)
				{
					break;
				}
			}
			foreach (List<Point> item2 in list2)
			{
				list.Add(new Region(item2, covered: false));
			}
			return list;
		}

		private static List<Point> Intersect(List<Point> polygon, Circle circle)
		{
			if (Outside(polygon, circle))
			{
				return new List<Point>();
			}
			if (Inside(polygon, circle))
			{
				return polygon;
			}
			for (int i = 0; i < circle.Segments; i++)
			{
				if (!Valid(polygon))
				{
					break;
				}
				Edge(circle, i, out var a, out var b);
				polygon = Clip(polygon, a, b, inside: true);
			}
			return polygon;
		}

		private static void Edge(Circle circle, int edge, out Point a, out Point b)
		{
			double num = (double)edge * Math.PI * 2.0 / (double)circle.Segments;
			double num2 = (double)(edge + 1) * Math.PI * 2.0 / (double)circle.Segments;
			a = new Point(circle.X + Math.Cos(num) * circle.Radius, circle.Z + Math.Sin(num) * circle.Radius);
			b = new Point(circle.X + Math.Cos(num2) * circle.Radius, circle.Z + Math.Sin(num2) * circle.Radius);
		}

		private static bool Inside(List<Point> polygon, Circle circle)
		{
			double innerRadius = circle.InnerRadius;
			double num = innerRadius * innerRadius;
			foreach (Point item in polygon)
			{
				if ((item.X - circle.X) * (item.X - circle.X) + (item.Z - circle.Z) * (item.Z - circle.Z) > num)
				{
					return false;
				}
			}
			return true;
		}

		private static bool Outside(List<Point> polygon, Circle circle)
		{
			double num = double.PositiveInfinity;
			double num2 = num;
			double num3 = double.NegativeInfinity;
			double num4 = num3;
			foreach (Point item in polygon)
			{
				num = Math.Min(num, item.X);
				num3 = Math.Max(num3, item.X);
				num2 = Math.Min(num2, item.Z);
				num4 = Math.Max(num4, item.Z);
			}
			double num5 = Math.Max(num - circle.X, Math.Max(0.0, circle.X - num3));
			double num6 = Math.Max(num2 - circle.Z, Math.Max(0.0, circle.Z - num4));
			return num5 * num5 + num6 * num6 >= circle.Radius * circle.Radius;
		}

		private static List<Point> Clip(List<Point> polygon, Point a, Point b, bool inside)
		{
			List<Point> list = new List<Point>();
			if (polygon.Count == 0)
			{
				return list;
			}
			Point point = polygon[polygon.Count - 1];
			double num = Side(point, a, b);
			bool flag = (inside ? (num >= 0.0) : (num <= 0.0));
			foreach (Point item in polygon)
			{
				double num2 = Side(item, a, b);
				bool num3 = (inside ? (num2 >= 0.0) : (num2 <= 0.0));
				if (num3 != flag)
				{
					double num4 = num / (num - num2);
					list.Add(new Point(point.X + (item.X - point.X) * num4, point.Z + (item.Z - point.Z) * num4));
				}
				if (num3)
				{
					list.Add(item);
				}
				point = item;
				num = num2;
				flag = num3;
			}
			return list;
		}

		private static double Side(Point point, Point a, Point b)
		{
			return (b.X - a.X) * (point.Z - a.Z) - (b.Z - a.Z) * (point.X - a.X);
		}

		private static bool Valid(List<Point> points)
		{
			if (points.Count >= 3)
			{
				return Area(points) > 1E-09;
			}
			return false;
		}

		private static bool Finite(double value)
		{
			if (!double.IsNaN(value))
			{
				return !double.IsInfinity(value);
			}
			return false;
		}

		public static double Area(IReadOnlyList<Point> points)
		{
			double num = 0.0;
			for (int i = 0; i < points.Count; i++)
			{
				Point point = points[(i + 1) % points.Count];
				num += points[i].X * point.Z - point.X * points[i].Z;
			}
			return Math.Abs(num) * 0.5;
		}
	}
}
namespace ExtraPotions.Hex.Ghost
{
	public readonly struct GhostKey : IEquatable<GhostKey>, IComparable<GhostKey>
	{
		public long User { get; }

		public uint Id { get; }

		public bool IsNone
		{
			get
			{
				if (User == 0L)
				{
					return Id == 0;
				}
				return false;
			}
		}

		public GhostKey(long user, uint id)
		{
			User = user;
			Id = id;
		}

		public bool Equals(GhostKey other)
		{
			if (User == other.User)
			{
				return Id == other.Id;
			}
			return false;
		}

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

		public override int GetHashCode()
		{
			return (User.GetHashCode() * 397) ^ (int)Id;
		}

		public int CompareTo(GhostKey other)
		{
			int num = User.CompareTo(other.User);
			if (num == 0)
			{
				return Id.CompareTo(other.Id);
			}
			return num;
		}

		public static bool operator ==(GhostKey a, GhostKey b)
		{
			return a.Equals(b);
		}

		public static bool operator !=(GhostKey a, GhostKey b)
		{
			return !a.Equals(b);
		}

		public override string ToString()
		{
			return User + ":" + Id;
		}
	}
	public enum GhostVerb : byte
	{
		Off,
		On
	}
	public enum GhostState : byte
	{
		Off,
		Confirmed,
		Refused
	}
	public enum GhostReason : byte
	{
		None,
		Inactive,
		Character,
		Denied,
		Capacity,
		Vanilla
	}
	public readonly struct GhostAnswer : IEquatable<GhostAnswer>
	{
		public GhostState State { get; }

		public GhostReason Reason { get; }

		public bool Keeps => State == GhostState.Confirmed;

		public GhostAnswer(GhostState state, GhostReason reason)
		{
			State = state;
			Reason = reason;
		}

		public bool Equals(GhostAnswer other)
		{
			if (State == other.State)
			{
				return Reason == other.Reason;
			}
			return false;
		}

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

		public override int GetHashCode()
		{
			return (int)State * 16 + (int)Reason;
		}

		public override string ToString()
		{
			return State.ToString() + ((Reason == GhostReason.None) ? "" : (":" + Reason));
		}
	}
	public static class GhostDecision
	{
		public static GhostAnswer Decide(GhostVerb verb, bool active, bool characterMatches, bool allowed, bool capacityAvailable, bool vanillaBlocked = false)
		{
			if (!active)
			{
				return new GhostAnswer(GhostState.Refused, GhostReason.Inactive);
			}
			if (!characterMatches)
			{
				return new GhostAnswer(GhostState.Refused, GhostReason.Character);
			}
			if (verb == GhostVerb.Off)
			{
				return new GhostAnswer(GhostState.Off, GhostReason.None);
			}
			if (!allowed)
			{
				return new GhostAnswer(GhostState.Refused, GhostReason.Denied);
			}
			if (vanillaBlocked)
			{
				return new GhostAnswer(GhostState.Refused, GhostReason.Vanilla);
			}
			if (!capacityAvailable)
			{
				return new GhostAnswer(GhostState.Refused, GhostReason.Capacity);
			}
			return new GhostAnswer(GhostState.Confirmed, GhostReason.None);
		}
	}
	public readonly struct GhostRequestFacts : IEquatable<GhostRequestFacts>
	{
		public long Generation { get; }

		public GhostKey Character { get; }

		public bool Wish { get; }

		public bool Confirmed { get; }

		public string Stamp { get; }

		public GhostRequestFacts(long generation, GhostKey character, bool wish, bool confirmed, string stamp)
		{
			Generation = generation;
			Character = character;
			Wish = wish;
			Confirmed = confirmed;
			Stamp = stamp ?? "";
		}

		internal bool SameKey(GhostRequestFacts other)
		{
			if (Generation == other.Generation && Character == other.Character && Wish == other.Wish)
			{
				return string.Equals(Stamp, other.Stamp, StringComparison.Ordinal);
			}
			return false;
		}

		public bool Equals(GhostRequestFacts other)
		{
			if (SameKey(other))
			{
				return Confirmed == other.Confirmed;
			}
			return false;
		}

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

		public override int GetHashCode()
		{
			return (int)((uint)((Generation.GetHashCode() * 397) ^ Character.GetHashCode()) ^ (Wish ? 1u : 0u)) ^ Stamp.GetHashCode();
		}
	}
	public sealed class GhostRequester
	{
		public const double Spacing = 1.0;

		public const double FailureDelay = 5.0;

		public const int MaxAttempts = 3;

		private GhostRequestFacts? current;

		private GhostRequestFacts? sent;

		private int attempts;

		private bool answered;

		private bool inFlight;

		private double nextAllowed = double.NegativeInfinity;

		public bool InFlight => inFlight;

		public GhostVerb? Next(double now, GhostRequestFacts facts)
		{
			if (facts.Character.IsNone)
			{
				return null;
			}
			if (!current.HasValue || !current.Value.SameKey(facts))
			{
				current = facts;
				attempts = 0;
				answered = false;
			}
			if (facts.Wish == facts.Confirmed || inFlight || answered || attempts >= 3 || now < nextAllowed)
			{
				return null;
			}
			attempts++;
			inFlight = true;
			sent = facts;
			nextAllowed = now + 1.0;
			return facts.Wish ? GhostVerb.On : GhostVerb.Off;
		}

		public void Completed(double now, bool wasAnswered)
		{
			if (!inFlight)
			{
				return;
			}
			inFlight = false;
			bool flag = sent.HasValue && current.HasValue && sent.Value.SameKey(current.Value);
			if (wasAnswered)
			{
				if (flag)
				{
					answered = true;
				}
			}
			else
			{
				nextAllowed = Math.Max(nextAllowed, now + 5.0);
			}
			sent = null;
		}

		public void Reset()
		{
			current = (sent = null);
			attempts = 0;
			answered = (inFlight = false);
			nextAllowed = double.NegativeInfinity;
		}
	}
	public sealed class GhostPublisher
	{
		private sealed class Peer
		{
			public long Delivered = -1L;

			public bool InFlight;

			public double NextAttempt;

			public int Failures;
		}

		public const double Spacing = 2.0;

		public const double MaxBackoff = 10.0;

		private readonly Dictionary<string, Peer> peers = new Dictionary<string, Peer>(StringComparer.Ordinal);

		public bool Due(string peer, long revision, bool empty, double now)
		{
			if (!peers.TryGetValue(peer, out Peer value))
			{
				return !empty;
			}
			if (!value.InFlight && value.Delivered != revision)
			{
				return now >= value.NextAttempt;
			}
			return false;
		}

		public void Sent(string peer, long revision, double now)
		{
			if (!peers.TryGetValue(peer, out Peer value))
			{
				value = (peers[peer] = new Peer());
			}
			value.InFlight = true;
			value.NextAttempt = now + 2.0;
		}

		public void Delivered(string peer, long revision)
		{
			if (peers.TryGetValue(peer, out Peer value))
			{
				value.InFlight = false;
				value.Delivered = revision;
				value.Failures = 0;
			}
		}

		public void Failed(string peer, double now)
		{
			if (peers.TryGetValue(peer, out Peer value))
			{
				value.InFlight = false;
				value.Failures = Math.Min(value.Failures + 1, 8);
				value.NextAttempt = now + Math.Min(10.0, Math.Pow(2.0, value.Failures));
			}
		}

		public void Retain(IEnumerable<string> live)
		{
			if (peers.Count == 0)
			{
				return;
			}
			ICollection<string> collection = (live as ICollection<string>) ?? new HashSet<string>(live ?? Array.Empty<string>(), StringComparer.Ordinal);
			List<string> list = null;
			foreach (string key in peers.Keys)
			{
				if (!collection.Contains(key))
				{
					(list ?? (list = new List<string>())).Add(key);
				}
			}
			if (list == null)
			{
				return;
			}
			foreach (string item in list)
			{
				peers.Remove(item);
			}
		}

		public void Clear()
		{
			peers.Clear();
		}
	}
	public enum GhostVanillaPolicy
	{
		Allow,
		Refuse
	}
	public static class GhostVanillaRule
	{
		public const GhostVanillaPolicy Default = GhostVanillaPolicy.Allow;

		public static bool Blocks(GhostVanillaPolicy policy, bool vanillaClientsConnected)
		{
			return policy == GhostVanillaPolicy.Refuse && vanillaClientsConnected;
		}

		public static bool VanillaPresent(GhostVanillaPolicy policy, bool known, bool anyVanilla)
		{
			if (!known)
			{
				return policy == GhostVanillaPolicy.Refuse;
			}
			return anyVanilla;
		}

		public static bool BlocksForPeer(bool pending, bool crucible, bool hasHex)
		{
			if (!pending)
			{
				if (crucible)
				{
					return !hasHex;
				}
				return true;
			}
			return false;
		}
	}
	public sealed class GhostVanillaGrace
	{
		public const double GraceSeconds = 5.0;

		private double since = double.NaN;

		public bool Blocks(GhostVanillaPolicy policy, bool known, bool anyVanilla, double now)
		{
			if (policy != GhostVanillaPolicy.Refuse || (known && !anyVanilla))
			{
				since = double.NaN;
				return false;
			}
			if (!known)
			{
				since = double.NaN;
				return true;
			}
			if (double.IsNaN(since))
			{
				since = now;
			}
			return now - since >= 5.0;
		}

		public void Reset()
		{
			since = double.NaN;
		}
	}
	public static class GhostNotices
	{
		public const string RevokedKey = "ghost_revoked";

		public const string SettingKey = "ghost_vanilla_setting";

		public static IReadOnlyList<string> TextKeys { get; } = new string[7] { "ghost_refused_inactive", "ghost_refused_character", "ghost_refused_denied", "ghost_refused_capacity", "ghost_refused_vanilla", "ghost_revoked", "ghost_vanilla_setting" };

		public static string? RefusalKey(GhostReason reason)
		{
			return reason switch
			{
				GhostReason.Inactive => "ghost_refused_inactive", 
				GhostReason.Character => "ghost_refused_character", 
				GhostReason.Denied => "ghost_refused_denied", 
				GhostReason.Capacity => "ghost_refused_capacity", 
				GhostReason.Vanilla => "ghost_refused_vanilla", 
				_ => null, 
			};
		}

		public static string? For(GhostAnswer answer)
		{
			if (answer.State != GhostState.Refused)
			{
				return null;
			}
			return RefusalKey(answer.Reason);
		}
	}
	public sealed class GhostRegistry
	{
		public const int MaxEntries = 256;

		private readonly Dictionary<string, GhostKey> entries = new Dictionary<string, GhostKey>(StringComparer.Ordinal);

		private readonly HashSet<GhostKey> keys = new HashSet<GhostKey>();

		public long Revision { get; private set; }

		public int Count => entries.Count;

		public bool Has(string peer)
		{
			if (peer != null)
			{
				return entries.ContainsKey(peer);
			}
			return false;
		}

		public bool Contains(GhostKey key)
		{
			if (!key.IsNone)
			{
				return keys.Contains(key);
			}
			return false;
		}

		public bool CanAdmit(string peer)
		{
			if (!Has(peer))
			{
				return entries.Count < 256;
			}
			return true;
		}

		public bool Grant(string peer, GhostKey key)
		{
			if (string.IsNullOrEmpty(peer))
			{
				throw new ArgumentException("Expected a peer.", "peer");
			}
			if (key.IsNone)
			{
				throw new ArgumentException("Expected a character.", "key");
			}
			if (entries.TryGetValue(peer, out var value) && value == key)
			{
				return false;
			}
			if (!CanAdmit(peer))
			{
				throw new InvalidOperationException("Ghost registry is full.");
			}
			entries[peer] = key;
			Rebuild();
			return true;
		}

		public bool Revoke(string peer)
		{
			if (peer == null || !entries.Remove(peer))
			{
				return false;
			}
			Rebuild();
			return true;
		}

		public IReadOnlyList<string> RetainWhere(Func<string, GhostKey, bool> keep)
		{
			if (keep == null)
			{
				throw new ArgumentNullException("keep");
			}
			string[] array = (from pair in entries
				where !keep(pair.Key, pair.Value)
				select pair.Key).OrderBy<string, string>((string p) => p, StringComparer.Ordinal).ToArray();
			if (array.Length == 0)
			{
				return array;
			}
			string[] array2 = array;
			foreach (string key in array2)
			{
				entries.Remove(key);
			}
			Rebuild();
			return array;
		}

		public void Clear()
		{
			if (entries.Count != 0)
			{
				entries.Clear();
				Rebuild();
			}
		}

		public GhostKey[] Snapshot()
		{
			return keys.OrderBy((GhostKey k) => k).ToArray();
		}

		private void Rebuild()
		{
			keys.Clear();
			foreach (GhostKey value in entries.Values)
			{
				keys.Add(value);
			}
			checked
			{
				Revision++;
			}
		}
	}
	public sealed class GhostView
	{
		private readonly HashSet<GhostKey> keys = new HashSet<GhostKey>();

		private long generation = -1L;

		private long revision = -1L;

		public int Count => keys.Count;

		public long Generation => generation;

		public bool Contains(GhostKey key)
		{
			if (!key.IsNone)
			{
				return keys.Contains(key);
			}
			return false;
		}

		public void Reset(long sessionGeneration)
		{
			generation = sessionGeneration;
			revision = -1L;
			keys.Clear();
		}

		public bool Accept(long sessionGeneration, long setRevision, IReadOnlyCollection<GhostKey> set)
		{
			if (set == null || sessionGeneration != generation || setRevision <= revision)
			{
				return false;
			}
			revision = setRevision;
			keys.Clear();
			foreach (GhostKey item in set)
			{
				if (!item.IsNone)
				{
					keys.Add(item);
				}
			}
			return true;
		}
	}
	public sealed class GhostSet
	{
		public long Revision { get; }

		public IReadOnlyList<GhostKey> Keys { get; }

		public GhostSet(long revision, IReadOnlyList<GhostKey> keys)
		{
			Revision = revision;
			Keys = keys;
		}
	}
	public static class GhostWire
	{
		public const byte Version = 1;

		public const int MaxEntries = 256;

		private const int KeySize = 12;

		private const int SetHeader = 11;

		public static byte[] EncodeRequest(GhostVerb verb, GhostKey key)
		{
			if (verb != GhostVerb.On && verb != GhostVerb.Off)
			{
				throw new ArgumentException("Unknown verb.", "verb");
			}
			byte[] obj = new byte[14]
			{
				1,
				(byte)verb,
				0,
				0,
				0,
				0,
				0,
				0,
				0,
				0,
				0,
				0,
				0,
				0
			};
			WriteKey(obj, 2, key);
			return obj;
		}

		public static (GhostVerb Verb, GhostKey Key) DecodeRequest(byte[] bytes)
		{
			if (bytes == null || bytes.Length != 14 || bytes[0] != 1)
			{
				throw new FormatException("Malformed Ghost request.");
			}
			if (bytes[1] > 1)
			{
				throw new FormatException("Unknown Ghost verb.");
			}
			GhostKey item = ReadKey(bytes, 2);
			if (item.IsNone)
			{
				throw new FormatException("Ghost request without a character.");
			}
			return (Verb: (GhostVerb)bytes[1], Key: item);
		}

		public static byte[] EncodeAnswer(GhostAnswer answer)
		{
			return new byte[3]
			{
				1,
				(byte)answer.State,
				(byte)answer.Reason
			};
		}

		public static GhostAnswer DecodeAnswer(byte[] bytes)
		{
			if (bytes == null || bytes.Length != 3 || bytes[0] != 1)
			{
				throw new FormatException("Malformed Ghost answer.");
			}
			if (bytes[1] > 2 || bytes[2] > 5)
			{
				throw new FormatException("Unknown Ghost answer.");
			}
			return new GhostAnswer((GhostState)bytes[1], (GhostReason)bytes[2]);
		}

		public static byte[] EncodeSet(long revision, IReadOnlyCollection<GhostKey> keys)
		{
			if (keys == null)
			{
				throw new ArgumentNullException("keys");
			}
			if (revision < 0)
			{
				throw new ArgumentException("Negative revision.", "revision");
			}
			GhostKey[] array = (from k in keys.Distinct()
				orderby k
				select k).ToArray();
			if (array.Length > 256)
			{
				throw new ArgumentException("Too many Ghost entries.", "keys");
			}
			if (array.Any((GhostKey k) => k.IsNone))
			{
				throw new ArgumentException("Ghost set with an empty character.", "keys");
			}
			byte[] array2 = new byte[11 + array.Length * 12];
			array2[0] = 1;
			WriteLong(array2, 1, revision);
			array2[9] = (byte)(array.Length >> 8);
			array2[10] = (byte)array.Length;
			for (int num = 0; num < array.Length; num++)
			{
				WriteKey(array2, 11 + num * 12, array[num]);
			}
			return array2;
		}

		public static GhostSet DecodeSet(byte[] bytes)
		{
			if (bytes == null || bytes.Length < 11 || bytes[0] != 1)
			{
				throw new FormatException("Malformed Ghost set.");
			}
			long num = ReadLong(bytes, 1);
			if (num < 0)
			{
				throw new FormatException("Negative Ghost revision.");
			}
			int num2 = (bytes[9] << 8) | bytes[10];
			if (num2 > 256 || bytes.Length != 11 + num2 * 12)
			{
				throw new FormatException("Ghost set length mismatch.");
			}
			GhostKey[] array = new GhostKey[num2];
			for (int i = 0; i < num2; i++)
			{
				array[i] = ReadKey(bytes, 11 + i * 12);
				if (array[i].IsNone)
				{
					throw new FormatException("Ghost set with an empty character.");
				}
				if (i > 0 && array[i - 1].CompareTo(array[i]) >= 0)
				{
					throw new FormatException("Ghost set is not strictly ordered.");
				}
			}
			return new GhostSet(num, array);
		}

		public static byte[] EncodeAck()
		{
			return new byte[2] { 1, 1 };
		}

		public static bool DecodeAck(byte[] bytes)
		{
			if (bytes == null || bytes.Length != 2 || bytes[0] != 1 || bytes[1] != 1)
			{
				throw new FormatException("Malformed Ghost acknowledgment.");
			}
			return true;
		}

		private static void WriteKey(byte[] bytes, int at, GhostKey key)
		{
			WriteLong(bytes, at, key.User);
			for (int i = 0; i < 4; i++)
			{
				bytes[at + 8 + i] = (byte)(key.Id >> 24 - 8 * i);
			}
		}

		private static GhostKey ReadKey(byte[] bytes, int at)
		{
			uint num = 0u;
			for (int i = 0; i < 4; i++)
			{
				num = (num << 8) | bytes[at + 8 + i];
			}
			return new GhostKey(ReadLong(bytes, at), num);
		}

		private static void WriteLong(byte[] bytes, int at, long value)
		{
			for (int i = 0; i < 8; i++)
			{
				bytes[at + i] = (byte)(value >> 56 - 8 * i);
			}
		}

		private static long ReadLong(byte[] bytes, int at)
		{
			long num = 0L;
			for (int i = 0; i < 8; i++)
			{
				num = (num << 8) | bytes[at + i];
			}
			return num;
		}
	}
}