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 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.5.13.0")]
[assembly: AssemblyInformationalVersion("0.5.13")]
[assembly: AssemblyProduct("Wayfarer.Core")]
[assembly: AssemblyTitle("Wayfarer.Core")]
[assembly: AssemblyVersion("0.5.13.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 Wayfarer.Core
{
	public readonly struct DeathPinCandidate
	{
		public readonly float X;

		public readonly float Z;

		public readonly string? Name;

		public readonly bool Saved;

		public readonly bool Death;

		public readonly bool ForeignAuthor;

		public readonly long OwnerId;

		public DeathPinCandidate(float x, float z, string? name, bool saved, bool death, long ownerId, bool foreignAuthor)
		{
			X = x;
			Z = z;
			Name = name;
			Saved = saved;
			Death = death;
			OwnerId = ownerId;
			ForeignAuthor = foreignAuthor;
		}
	}
	public static class DeathPinCleanup
	{
		public const float MatchRadius = 1f;

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

		public static int FindUnique(IReadOnlyList<DeathPinCandidate> pins, float originalX, float originalZ, int nativeDay, long localPlayerId)
		{
			if (pins == null || localPlayerId == 0L || nativeDay < 0 || !Finite(originalX) || !Finite(originalZ))
			{
				return -1;
			}
			string b = "$hud_mapday " + nativeDay.ToString(CultureInfo.InvariantCulture);
			int num = -1;
			for (int i = 0; i < pins.Count; i++)
			{
				DeathPinCandidate deathPinCandidate = pins[i];
				if (!deathPinCandidate.Saved || !deathPinCandidate.Death || deathPinCandidate.ForeignAuthor || (deathPinCandidate.OwnerId != 0L && deathPinCandidate.OwnerId != localPlayerId) || !string.Equals(deathPinCandidate.Name, b, StringComparison.Ordinal) || !Finite(deathPinCandidate.X) || !Finite(deathPinCandidate.Z))
				{
					continue;
				}
				double num2 = (double)deathPinCandidate.X - (double)originalX;
				double num3 = (double)deathPinCandidate.Z - (double)originalZ;
				if (!(num2 * num2 + num3 * num3 >= 1.0))
				{
					if (num >= 0)
					{
						return -1;
					}
					num = i;
				}
			}
			return num;
		}
	}
	public enum Category
	{
		Bed,
		Stones,
		Map,
		Boat,
		Grave,
		Player
	}
	public sealed class Destination
	{
		public string Id { get; }

		public Category Category { get; }

		public string LabelKey { get; }

		public long WorldId { get; }

		public bool IsLastKnown { get; set; }

		public string Name { get; set; } = "";

		public float X { get; set; }

		public float Y { get; set; }

		public float Z { get; set; }

		public Destination(string id, Category category, string labelKey, long worldId)
		{
			Id = id;
			Category = category;
			LabelKey = labelKey;
			WorldId = worldId;
		}
	}
	public static class DestinationPolicy
	{
		public static bool SharedPlayer(bool online, bool sharesPosition, bool isLocal)
		{
			if (online && sharesPosition)
			{
				return !isLocal;
			}
			return false;
		}

		public static bool CanSelect(Destination d, long worldId, bool advancedEnabled)
		{
			if (d.WorldId == worldId)
			{
				if (!advancedEnabled && d.Category != Category.Bed && d.Category != Category.Stones)
				{
					return d.Category == Category.Map;
				}
				return true;
			}
			return false;
		}
	}
	public static class LandingPolicy
	{
		public static bool Clear(bool areaReady, float normalY, bool clear, bool water)
		{
			if (areaReady && clear)
			{
				if (!water)
				{
					return normalY >= 0.65f;
				}
				return true;
			}
			return false;
		}

		public static float CorrectHeight(float supplied, float floor, float water)
		{
			return Math.Max(floor, water) + 0.6f;
		}

		public static bool IsValid(float x, float y, float z)
		{
			if (!float.IsNaN(x) && !float.IsNaN(y) && !float.IsNaN(z) && !float.IsInfinity(x) && !float.IsInfinity(y) && !float.IsInfinity(z) && Math.Abs(x) < 12000f)
			{
				return Math.Abs(z) < 12000f;
			}
			return false;
		}
	}
	public sealed class SelectionState
	{
		public bool Armed { get; private set; }

		public bool PickerOpen { get; private set; }

		public bool Advanced { get; private set; }

		public long WorldId { get; private set; }

		public void ChangeWorld(long world)
		{
			if (WorldId != world)
			{
				Close();
				WorldId = world;
			}
		}

		public void Arm()
		{
			Armed = !Armed;
			PickerOpen = false;
		}

		public void Close()
		{
			Armed = false;
			PickerOpen = false;
		}

		public void SetAdvanced(bool enabled)
		{
			Advanced = enabled;
			if (!enabled)
			{
				PickerOpen = false;
			}
		}

		public void SetEnabled(bool enabled)
		{
			if (!enabled)
			{
				Close();
			}
		}

		public void OpenPicker()
		{
			if (Advanced)
			{
				PickerOpen = true;
				Armed = false;
			}
		}
	}
	public sealed class ObservedDestinations
	{
		private long world;

		private readonly Dictionary<string, Destination> entries = new Dictionary<string, Destination>();

		public IReadOnlyCollection<Destination> Items => entries.Values;

		public void ChangeWorld(long id)
		{
			if (world != id)
			{
				entries.Clear();
				world = id;
			}
		}

		public void Put(Destination d)
		{
			if (d.WorldId == world)
			{
				entries[d.Id] = d;
			}
		}
	}
	public static class WayfarerIdentity
	{
		public const string Version = "0.5.13";

		public const string Family = "Mischief";
	}
	public static class ConfigurationKeys
	{
		public const string Enabled = "Enabled";

		public const string Language = "Language";

		public const string CloseMap = "CloseMap";

		public const string Messages = "ShowMessages";

		public const string TombstoneHints = "TombstoneHints";
	}
	public static class ServerConfigurationKeys
	{
		public const string Section = "Server";

		public const string AllowTeleport = "AllowTeleport";

		public const string AllowBed = "AllowBed";
	}
	public static class CheatKeys
	{
		public const string Section = "Cheats";

		public const string Stones = "TeleportToStones";

		public const string Map = "TeleportAnywhere";

		public const string Boat = "TeleportToBoat";

		public const string Grave = "TeleportToGrave";

		public const string Player = "TeleportToPlayer";

		public static string? For(Category category)
		{
			return category switch
			{
				Category.Player => "TeleportToPlayer", 
				Category.Grave => "TeleportToGrave", 
				Category.Boat => "TeleportToBoat", 
				Category.Map => "TeleportAnywhere", 
				Category.Stones => "TeleportToStones", 
				_ => null, 
			};
		}
	}
	public interface IWayfarerNavigation
	{
		NavigationSnapshot Snapshot();
	}
	public sealed class NavigationSnapshot
	{
		public bool WorldReady { get; }

		public bool Advanced { get; }

		public IReadOnlyList<Category> Categories { get; }

		public NavigationSnapshot(bool worldReady, bool advanced, IEnumerable<Category> categories)
		{
			WorldReady = worldReady;
			Advanced = advanced;
			Categories = Array.AsReadOnly(categories.ToArray());
		}
	}
	public sealed class NavigationProvider : IWayfarerNavigation
	{
		private readonly Func<NavigationSnapshot> snapshot;

		public NavigationProvider(Func<NavigationSnapshot> snapshot)
		{
			this.snapshot = snapshot ?? throw new ArgumentNullException("snapshot");
		}

		public NavigationSnapshot Snapshot()
		{
			return snapshot();
		}
	}
	public sealed class ProductPresentation
	{
		public string Title { get; }

		public string Brand { get; }

		public ProductPresentation(string title, string brand)
		{
			Title = title;
			Brand = brand;
		}
	}
	public readonly struct PanelRect
	{
		public float X { get; }

		public float Y { get; }

		public float Width { get; }

		public float Height { get; }

		public float Right => X + Width;

		public float Bottom => Y + Height;

		public PanelRect(float x, float y, float width, float height)
		{
			X = x;
			Y = y;
			Width = width;
			Height = height;
		}
	}
	public enum SlotKind
	{
		Text,
		Button,
		Icon,
		Tab,
		Switch
	}
	public readonly struct PanelSlot
	{
		public string Name { get; }

		public SlotKind Kind { get; }

		public PanelRect Rect { get; }

		public int Row { get; }

		public int Column { get; }

		public int Span { get; }

		public bool Focusable => Row >= 0;

		public PanelSlot(string name, SlotKind kind, PanelRect rect, int row = -1, int column = 0, int span = 1)
		{
			Name = name;
			Kind = kind;
			Rect = rect;
			Row = row;
			Column = column;
			Span = span;
		}

		public IEnumerable<(int X, int Y)> Cells()
		{
			for (int i = 0; i < Span; i++)
			{
				yield return (X: Column + i, Y: Row);
			}
		}
	}
	public sealed class PanelScreen
	{
		public string Id { get; }

		public float Height { get; }

		public int Columns { get; }

		public IReadOnlyList<PanelSlot> Slots { get; }

		public PanelSlot this[string name] => Slots.First((PanelSlot s) => s.Name == name);

		public PanelScreen(string id, float height, int columns, IReadOnlyList<PanelSlot> slots)
		{
			Id = id;
			Height = height;
			Columns = columns;
			Slots = slots;
		}

		public bool Has(string name)
		{
			return Slots.Any((PanelSlot s) => s.Name == name);
		}
	}
	public static class PanelLayout
	{
		public const float Width = 370f;

		public const float Left = 12f;

		public const float Inner = 346f;

		public const float Top = 62f;

		public const float Row = 46f;

		public const float ButtonHeight = 40f;

		public const float MinScale = 0.3f;

		public const float Edge = 24f;

		public const float TabHeight = 26f;

		public const float TabBetween = 6f;

		public const int PageSize = 6;

		public const int PickerColumns = 6;

		public const float DefaultLeft = 0.084f;

		public const float DefaultTop = 0.392f;

		public static readonly string[] MainActions = new string[4] { "Bed", "Stones", "Map", "Advanced" };

		private static PanelSlot[] Header()
		{
			return new PanelSlot[2]
			{
				new PanelSlot("Title", SlotKind.Text, new PanelRect(12f, 4f, 270f, 30f)),
				new PanelSlot("Brand", SlotKind.Text, new PanelRect(12f, 31f, 270f, 20f))
			};
		}

		public static PanelScreen Main(IEnumerable<string> allowed)
		{
			string[] array = MainActions.Where(allowed.Contains<string>).ToArray();
			List<PanelSlot> list = Header().ToList();
			for (int i = 0; i < array.Length; i++)
			{
				list.Add(new PanelSlot(array[i], SlotKind.Button, new PanelRect(12f, 62f + 46f * (float)i, 346f, 40f), i));
			}
			if (array.Length == 0)
			{
				list.Add(new PanelSlot("PolicyDenied", SlotKind.Text, new PanelRect(12f, 62f, 346f, 40f)));
			}
			return new PanelScreen("main", 124f + 46f * (float)Math.Max(0, array.Length - 1), 1, list);
		}

		public static PanelRect Tab(int index, int count)
		{
			if (count <= 0 || index < 0 || index >= count)
			{
				throw new ArgumentOutOfRangeException("index");
			}
			float num = (346f - 6f * (float)(count - 1)) / (float)count;
			return new PanelRect(12f + (float)index * (num + 6f), 62f, num, 26f);
		}

		public static PanelScreen Picker(int categories, int shown)
		{
			if (categories < 1 || categories > 3)
			{
				throw new ArgumentOutOfRangeException("categories");
			}
			if (shown < 0 || shown > 6)
			{
				throw new ArgumentOutOfRangeException("shown");
			}
			List<PanelSlot> list = Header().ToList();
			int num = 6 / categories;
			for (int i = 0; i < categories; i++)
			{
				list.Add(new PanelSlot("Category" + i, SlotKind.Tab, Tab(i, categories), 0, i * num, num));
			}
			list.Add(new PanelSlot("Help", SlotKind.Text, new PanelRect(12f, 96f, 346f, 64f)));
			if (shown == 0)
			{
				list.Add(new PanelSlot("Empty", SlotKind.Text, new PanelRect(12f, 168f, 346f, 48f)));
			}
			for (int j = 0; j < shown; j++)
			{
				list.Add(new PanelSlot("Destination" + j, SlotKind.Button, new PanelRect(12f, 168 + j * 39, 346f, 34f), 1 + j, 0, 6));
			}
			int num2 = 1 + shown;
			list.Add(new PanelSlot("Previous", SlotKind.Button, new PanelRect(12f, 409f, 46f, 30f), num2, 0, 2));
			list.Add(new PanelSlot("Page", SlotKind.Text, new PanelRect(74f, 409f, 100f, 30f)));
			list.Add(new PanelSlot("Next", SlotKind.Button, new PanelRect(180f, 409f, 46f, 30f), num2, 2, 2));
			list.Add(new PanelSlot("Refresh", SlotKind.Button, new PanelRect(232f, 409f, 126f, 30f), num2, 4, 2));
			list.Add(new PanelSlot("Cancel", SlotKind.Button, new PanelRect(12f, 450f, 346f, 40f), num2 + 1, 0, 6));
			return new PanelScreen("picker", 510f, 6, list);
		}

		public static float Scale(float parentWidth, float parentHeight, float height)
		{
			return Math.Max(0.3f, Math.Min(1f, Math.Min((parentHeight - 24f) / height, (parentWidth - 24f) / 370f)));
		}

		public static (float X, float Y) Position(float ratioX, float ratioY, float parentWidth, float parentHeight, float scaledWidth, float scaledHeight)
		{
			return (X: Clamp(ratioX * parentWidth, 0f, Math.Max(0f, parentWidth - scaledWidth)), Y: Clamp(ratioY * parentHeight, 0f, Math.Max(0f, parentHeight - scaledHeight)));
		}

		private static float Clamp(float value, float min, float max)
		{
			if (!(value < min))
			{
				if (!(value > max))
				{
					return value;
				}
				return max;
			}
			return min;
		}

		public static (int Pages, int Page, int Shown) Page(int count, int page)
		{
			int num = Math.Max(1, (count + 6 - 1) / 6);
			int num2 = Math.Max(0, Math.Min(page, num - 1));
			return (Pages: num, Page: num2, Shown: Math.Max(0, Math.Min(6, count - num2 * 6)));
		}
	}
	public sealed class PendingTeleport
	{
		private readonly TeleportActorFacts actor;

		private readonly TeleportRequest request;

		private readonly long generation;

		private readonly double deadline;

		private readonly TeleportTargetFacts departure;

		private bool canceled;

		private bool movement;

		private bool recovered;

		private double recoveryDeadline;

		public PendingTeleport(TeleportActorFacts actor, TeleportRequest request, long generation, double now, float departureX, float departureY, float departureZ)
		{
			this.actor = actor;
			this.request = request;
			this.generation = generation;
			deadline = now + 10.0;
			departure = new TeleportTargetFacts(LandingPolicy.IsValid(departureX, departureY, departureZ), departureX, departureY, departureZ);
		}

		private bool Same(TeleportActorFacts live, long currentGeneration)
		{
			if (currentGeneration == generation && actor.ActorId == live.ActorId && actor.WorldId == live.WorldId && actor.SessionId == live.SessionId)
			{
				return live.Present;
			}
			return false;
		}

		public void Cancel()
		{
			canceled = true;
		}

		public bool TryAccept(TeleportGrant grant, TeleportActorFacts live, long currentGeneration, double now, bool effectiveEnabled)
		{
			if (canceled || movement || !effectiveEnabled || !Same(live, currentGeneration) || !live.Alive || live.Teleporting || !live.CooldownReady || now >= deadline || now >= grant.ExpiresAt || grant.ActorId != actor.ActorId || grant.WorldId != actor.WorldId || grant.SessionId != actor.SessionId || grant.RequestId != request.RequestId || grant.Category != request.Category || grant.DestinationId != request.DestinationId)
			{
				return false;
			}
			movement = true;
			recoveryDeadline = now + 30.0;
			return true;
		}

		public bool TryRecovery(TeleportActorFacts live, long currentGeneration, double now, out TeleportTargetFacts capturedDeparture)
		{
			capturedDeparture = departure;
			if (!movement || recovered || !departure.Valid || now >= recoveryDeadline || !Same(live, currentGeneration) || !live.Alive || live.Teleporting)
			{
				return false;
			}
			recovered = true;
			return true;
		}
	}
	public sealed class PerFrame<T>
	{
		private readonly Func<int> frame;

		private readonly Func<T> compute;

		private int cachedFrame;

		private bool cached;

		private T value;

		public T Value
		{
			get
			{
				int num = frame();
				if (!cached || num != cachedFrame)
				{
					value = compute();
					cachedFrame = num;
					cached = true;
				}
				return value;
			}
		}

		public PerFrame(Func<int> frame, Func<T> compute)
		{
			this.frame = frame ?? throw new ArgumentNullException("frame");
			this.compute = compute ?? throw new ArgumentNullException("compute");
		}
	}
	public sealed class TeleportPolicy
	{
		public IReadOnlyCollection<Category> PlayerCategories { get; }

		public bool AllowTeleport { get; }

		public bool AllowBed { get; }

		public bool AllowStones { get; }

		public bool AllowMap { get; }

		public bool AllowBoat { get; }

		public bool AllowGrave { get; }

		public bool AllowPlayer { get; }

		public TeleportPolicy(bool allowTeleport = true, bool allowBed = true, bool allowStones = false, bool allowMap = false, bool allowBoat = false, bool allowGrave = false, bool allowPlayer = false, IReadOnlyCollection<Category>? playerCategories = null)
		{
			PlayerCategories = (IReadOnlyCollection<Category>)(((object)playerCategories) ?? ((object)Array.Empty<Category>()));
			AllowTeleport = allowTeleport;
			AllowBed = allowBed;
			AllowStones = allowStones;
			AllowMap = allowMap;
			AllowBoat = allowBoat;
			AllowGrave = allowGrave;
			AllowPlayer = allowPlayer;
		}

		public static bool IsCheat(Category category)
		{
			return category != Category.Bed;
		}

		public bool Enables(Category category)
		{
			if (AllowTeleport)
			{
				return category switch
				{
					Category.Player => AllowPlayer, 
					Category.Grave => AllowGrave, 
					Category.Boat => AllowBoat, 
					Category.Map => AllowMap, 
					Category.Stones => AllowStones, 
					Category.Bed => AllowBed, 
					_ => false, 
				};
			}
			return false;
		}

		public bool AllowsCategory(Category category, bool travelCheats)
		{
			return Refusal(category, travelCheats) == null;
		}

		public string? Refusal(Category category, bool travelCheats)
		{
			if (AllowTeleport)
			{
				if (Enables(category))
				{
					if (!IsCheat(category) || travelCheats || PlayerCategories.Contains(category))
					{
						return null;
					}
					return "travelrestricted";
				}
				return "destinationdisabled";
			}
			return "teleportdisabled";
		}
	}
	public static class TeleportRefusals
	{
		public const string TeleportDisabled = "teleportdisabled";

		public const string DestinationDisabled = "destinationdisabled";

		public const string TravelRestricted = "travelrestricted";

		public static readonly IReadOnlyList<string> Codes = Array.AsReadOnly(new string[3] { "teleportdisabled", "destinationdisabled", "travelrestricted" });

		public static bool Is(string? code)
		{
			if (code != null)
			{
				return Codes.Contains<string>(code);
			}
			return false;
		}
	}
	public sealed class TeleportRequest
	{
		public string RequestId { get; }

		public Category Category { get; }

		public string DestinationId { get; }

		public float X { get; }

		public float Y { get; }

		public float Z { get; }

		public bool IsLastKnown { get; }

		public TeleportRequest(string request, Category category, string destination, float x, float y, float z, bool isLastKnown = false)
		{
			Text(request);
			Text(destination);
			if (!Enum.IsDefined(typeof(Category), category))
			{
				throw new ArgumentException("Unknown category.");
			}
			RequestId = request;
			Category = category;
			DestinationId = destination;
			X = x;
			Y = y;
			Z = z;
			IsLastKnown = isLastKnown;
		}

		internal static void Text(string value)
		{
			if (string.IsNullOrWhiteSpace(value) || value.Length > 128 || value.IndexOfAny(new char[3] { '\0', '\r', '\n' }) >= 0)
			{
				throw new ArgumentException("Invalid teleport correlation.");
			}
		}
	}
	public sealed class TeleportActorFacts
	{
		public string ActorId { get; }

		public long WorldId { get; }

		public string SessionId { get; }

		public bool TravelCheats { get; }

		public bool Present { get; }

		public bool Alive { get; }

		public bool Teleporting { get; }

		public bool CooldownReady { get; }

		public TeleportActorFacts(string actor, long world, string session, bool travelCheats, bool present, bool alive, bool teleporting, bool cooldownReady)
		{
			TeleportRequest.Text(actor);
			TeleportRequest.Text(session);
			ActorId = actor;
			WorldId = world;
			SessionId = session;
			TravelCheats = travelCheats;
			Present = present;
			Alive = alive;
			Teleporting = teleporting;
			CooldownReady = cooldownReady;
		}
	}
	public sealed class TeleportTargetFacts
	{
		public bool Valid { get; }

		public float X { get; }

		public float Y { get; }

		public float Z { get; }

		public TeleportTargetFacts(bool valid, float x, float y, float z)
		{
			Valid = valid;
			X = x;
			Y = y;
			Z = z;
		}
	}
	public sealed class AuthorizationDecision
	{
		public bool Allowed { get; }

		public string Code { get; }

		public TeleportTargetFacts Target { get; }

		internal AuthorizationDecision(bool allowed, string code, TeleportTargetFacts target)
		{
			Allowed = allowed;
			Code = code;
			Target = target;
		}
	}
	public static class TeleportAuthorization
	{
		public static bool Advanced(Category category)
		{
			if (category != Category.Boat && category != Category.Grave)
			{
				return category == Category.Player;
			}
			return true;
		}

		public static AuthorizationDecision Evaluate(TeleportPolicy policy, TeleportActorFacts actor, TeleportRequest request, TeleportTargetFacts target)
		{
			string text = policy.Refusal(request.Category, actor.TravelCheats) ?? ((!actor.Present || actor.WorldId == 0L) ? "unavailable" : ((!actor.Alive) ? "dead" : ((actor.Teleporting || !actor.CooldownReady) ? "busy" : ((!LandingPolicy.IsValid(request.X, request.Y, request.Z) || !target.Valid || !LandingPolicy.IsValid(target.X, target.Y, target.Z)) ? "unavailable" : "success"))));
			return new AuthorizationDecision(text == "success", text, target);
		}
	}
	public sealed class TeleportGrant
	{
		public string ActorId { get; }

		public long WorldId { get; }

		public string SessionId { get; }

		public string RequestId { get; }

		public string GrantId { get; }

		public Category Category { get; }

		public string DestinationId { get; }

		public float X { get; }

		public float Y { get; }

		public float Z { get; }

		public double ExpiresAt { get; }

		public TeleportGrant(string actor, long world, string session, string request, string grant, Category category, string destination, float x, float y, float z, double expires)
		{
			TeleportRequest.Text(actor);
			TeleportRequest.Text(session);
			TeleportRequest.Text(request);
			TeleportRequest.Text(grant);
			TeleportRequest.Text(destination);
			if (world == 0L || !Enum.IsDefined(typeof(Category), category) || !LandingPolicy.IsValid(x, y, z) || double.IsNaN(expires) || double.IsInfinity(expires))
			{
				throw new ArgumentException("Invalid grant.");
			}
			ActorId = actor;
			WorldId = world;
			SessionId = session;
			RequestId = request;
			GrantId = grant;
			Category = category;
			DestinationId = destination;
			X = x;
			Y = y;
			Z = z;
			ExpiresAt = expires;
		}
	}
	public sealed class TeleportCompletion
	{
		public string RequestId { get; }

		public string GrantId { get; }

		public bool Accepted { get; }

		public TeleportCompletion(string request, string grant, bool accepted)
		{
			TeleportRequest.Text(request);
			TeleportRequest.Text(grant);
			RequestId = request;
			GrantId = grant;
			Accepted = accepted;
		}
	}
	public sealed class TeleportGrantLedger
	{
		private sealed class Entry
		{
			internal TeleportGrant Grant;

			internal bool Consumed;

			internal bool Completed;
		}

		private readonly Dictionary<(string, long, string, string), Entry> entries = new Dictionary<(string, long, string, string), Entry>();

		private static (string, long, string, string) Key(TeleportGrant grant)
		{
			return (grant.ActorId, grant.WorldId, grant.SessionId, grant.RequestId);
		}

		public TeleportGrant? Issue(TeleportActorFacts actor, TeleportRequest request, AuthorizationDecision decision, double now)
		{
			(string, long, string, string) key = (actor.ActorId, actor.WorldId, actor.SessionId, request.RequestId);
			if (!decision.Allowed || entries.ContainsKey(key) || entries.Count >= 4096 || entries.Values.Any((Entry e) => e.Grant.ActorId == actor.ActorId && !e.Completed && now < e.Grant.ExpiresAt))
			{
				return null;
			}
			TeleportTargetFacts target = decision.Target;
			TeleportGrant teleportGrant = new TeleportGrant(actor.ActorId, actor.WorldId, actor.SessionId, request.RequestId, Guid.NewGuid().ToString("N"), request.Category, request.DestinationId, target.X, target.Y, target.Z, now + 10.0);
			entries.Add(key, new Entry
			{
				Grant = teleportGrant
			});
			return teleportGrant;
		}

		public bool TrackVerifiedGrant(TeleportGrant grant)
		{
			(string, long, string, string) key = Key(grant);
			if (entries.ContainsKey(key) || entries.Count >= 4096)
			{
				return false;
			}
			entries.Add(key, new Entry
			{
				Grant = grant
			});
			return true;
		}

		public bool TryConsume(TeleportGrant grant, TeleportActorFacts liveActor, double now)
		{
			if (liveActor.ActorId != grant.ActorId || liveActor.WorldId != grant.WorldId || liveActor.SessionId != grant.SessionId || !liveActor.Present || !liveActor.Alive || liveActor.Teleporting || !liveActor.CooldownReady || now >= grant.ExpiresAt)
			{
				return false;
			}
			if (!entries.TryGetValue(Key(grant), out Entry value) || value.Consumed || value.Completed || value.Grant.GrantId != grant.GrantId || value.Grant.Category != grant.Category || value.Grant.DestinationId != grant.DestinationId || value.Grant.X != grant.X || value.Grant.Y != grant.Y || value.Grant.Z != grant.Z)
			{
				return false;
			}
			value.Consumed = true;
			return true;
		}

		public bool Complete(TeleportActorFacts actor, string request, string? grantId = null)
		{
			if (!entries.TryGetValue((actor.ActorId, actor.WorldId, actor.SessionId, request), out Entry value) || (grantId != null && value.Grant.GrantId != grantId))
			{
				return false;
			}
			value.Completed = true;
			return true;
		}

		public void Reset()
		{
			entries.Clear();
		}
	}
	public sealed class TombstoneNote
	{
		public string Cause { get; }

		public string Killer { get; }

		public int Day { get; }

		public TombstoneNote(string cause, string killer, int day)
		{
			Cause = cause ?? "";
			Killer = killer ?? "";
			Day = Math.Max(0, day);
		}
	}
	public static class TombstoneHints
	{
		public const bool DefaultEnabled = true;

		public const string SourceGuid = "JevMods.BetterTombstoneHints";

		public const string SourceName = "BetterTombstoneHints";

		public const string ModuleId = "tombstone_hints";

		public const string CauseField = "JevMods_Cause";

		public const string KillerField = "JevMods_Killer";

		public const string DayField = "JevMods_Day";

		public const int MaxName = 64;

		public const string Died = "died";

		public const string Slain = "slain";

		public const string SlainBy = "slain_by";

		public const string SlainByCreature = "slain_by_creature";

		private static readonly Dictionary<string, string> byHitType = new Dictionary<string, string>(StringComparer.Ordinal)
		{
			{ "Fall", "fall" },
			{ "Drowning", "drowning" },
			{ "Burning", "burning" },
			{ "Freezing", "freezing" },
			{ "Poisoned", "poisoned" },
			{ "Water", "water" },
			{ "Smoke", "smoke" },
			{ "EdgeOfWorld", "edge_of_world" },
			{ "Impact", "impact" },
			{ "Cart", "cart" },
			{ "Tree", "tree" },
			{ "Self", "self" },
			{ "Structural", "structural" },
			{ "Turret", "turret" },
			{ "Boat", "boat" },
			{ "Stalagtite", "stalactite" },
			{ "Catapult", "catapult" },
			{ "CinderFire", "cinder_fire" },
			{ "AshlandsOcean", "ashlands_ocean" },
			{ "AshlandsLava", "ashlands_lava" },
			{ "Incinerator", "incinerator" },
			{ "DrawBridge", "drawbridge" }
		};

		public static readonly IReadOnlyList<string> Causes = Array.AsReadOnly(new string[4] { "slain_by_creature", "slain_by", "slain", "died" }.Concat(byHitType.Values).ToArray());

		private static readonly Dictionary<string, string> nativeByCause = byHitType.ToDictionary<KeyValuePair<string, string>, string, string>((KeyValuePair<string, string> p) => p.Value, (KeyValuePair<string, string> p) => "$stat_DeathBy" + p.Key, StringComparer.Ordinal);

		public static string Key(string cause)
		{
			return "tomb_" + cause;
		}

		public static string NativeKey(string cause)
		{
			switch (cause)
			{
			case "slain_by_creature":
			case "slain_by":
			case "slain":
				return "$stat_DeathByEnemyHit";
			case "ashlands_lava":
				return "$stat_DeathByBurning";
			default:
			{
				if (nativeByCause.TryGetValue(cause, out string value))
				{
					return value;
				}
				goto case null;
			}
			case null:
				return "";
			}
		}

		public static string ForHitType(string hitType)
		{
			if (hitType == null || !byHitType.TryGetValue(hitType, out string value))
			{
				return "died";
			}
			return value;
		}

		public static TombstoneNote Death(string? hitType, object? attacker, bool attackerIsPlayer, bool attackerIsBoss, string attackerName, int day)
		{
			if (hitType == null)
			{
				return new TombstoneNote("died", "", day);
			}
			if (hitType == "EnemyHit" || hitType == "PlayerHit")
			{
				if (attacker == null)
				{
					return new TombstoneNote("slain", "", day);
				}
				return new TombstoneNote((attackerIsPlayer || attackerIsBoss) ? "slain_by" : "slain_by_creature", Clean(attackerName), day);
			}
			return new TombstoneNote(ForHitType(hitType), "", day);
		}

		public static string Render(TombstoneNote note, Func<string, string> localize, string dayText)
		{
			string text = NativeKey(Causes.Contains(note.Cause) ? note.Cause : "died");
			string text2 = ((text.Length == 0) ? "" : Clean(localize(text), 256));
			if (text2.StartsWith("[", StringComparison.Ordinal) && text2.EndsWith("]", StringComparison.Ordinal))
			{
				text2 = "";
			}
			string text3 = Clean(localize(Clean(note.Killer)));
			if (text3.Length > 0)
			{
				text2 = ((text2.Length == 0) ? text3 : (text2 + ": " + text3));
			}
			string text4 = Clean(dayText);
			if (text4.Length != 0)
			{
				if (text2.Length != 0)
				{
					return text2 + ", " + text4;
				}
				return text4;
			}
			return text2;
		}

		public static string Insert(string hoverText, string note)
		{
			if (hoverText.Length == 0 || note.Length == 0)
			{
				return hoverText;
			}
			int num = hoverText.IndexOf('\n');
			if (num >= 0)
			{
				return hoverText.Insert(num, "\n" + note);
			}
			return hoverText + "\n" + note;
		}

		public static bool StepsAside(IEnumerable<string> installedGuids)
		{
			return installedGuids.Contains<string>("JevMods.BetterTombstoneHints", StringComparer.Ordinal);
		}

		private static string Clean(string? value, int max = 64)
		{
			if (string.IsNullOrEmpty(value))
			{
				return "";
			}
			string text = new string(value.Where((char c) => c != '<' && c != '>' && c != '\r' && c != '\n').ToArray()).Trim();
			if (text.Length <= max)
			{
				return text;
			}
			return text.Substring(0, max);
		}
	}
	public static class WayfarerLanguages
	{
		public static readonly string[] Languages = new string[7] { "English", "Spanish", "Chinese", "Russian", "French", "German", "Korean" };

		public static string[] Settings => new string[1] { "Auto" }.Concat(Languages).ToArray();

		public static string Normalize(string language)
		{
			if (language.IndexOf("Chinese", StringComparison.OrdinalIgnoreCase) >= 0)
			{
				return "Chinese";
			}
			return Languages.FirstOrDefault((string l) => string.Equals(l, language, StringComparison.OrdinalIgnoreCase)) ?? "English";
		}

		public static string NameKey(string setting)
		{
			return "language_" + (string.Equals(setting, "Auto", StringComparison.OrdinalIgnoreCase) ? "auto" : Normalize(setting).ToLowerInvariant());
		}
	}
}