using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Text;
using System.Text.RegularExpressions;
using Microsoft.CodeAnalysis;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.0", FrameworkDisplayName = ".NET Standard 2.0")]
[assembly: AssemblyCompany("Laoch")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyCopyright("Copyright (c) Laoch")]
[assembly: AssemblyFileVersion("0.1.0.0")]
[assembly: AssemblyInformationalVersion("0.1.0+b6db23ff7b7805b7253c14474649d02fb69c35ec")]
[assembly: AssemblyProduct("DroppedAndLost")]
[assembly: AssemblyTitle("DroppedAndLost.Core")]
[assembly: AssemblyVersion("0.1.0.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace DroppedAndLost.Core
{
	public static class AccountId
	{
		private static readonly Regex Digits = new Regex("\\d{6,}", RegexOptions.Compiled);

		public static string Normalize(string raw)
		{
			if (string.IsNullOrEmpty(raw))
			{
				return "";
			}
			Match match = Digits.Match(raw);
			if (!match.Success)
			{
				return raw.Trim().ToLowerInvariant();
			}
			return match.Value;
		}
	}
	public struct PlayerSample
	{
		public long Id;

		public float X;

		public float Y;

		public float Z;

		public bool Alive;

		public bool Connected;
	}
	public struct BossDecision
	{
		public bool Allowed;

		public int Present;

		public int Needed;

		public string Message;
	}
	public static class BossGate
	{
		public static int CountPresent(DalSettings s, float altarX, float altarY, float altarZ, IList<PlayerSample> players, List<long> presentIds = null)
		{
			float num = s.BossPresenceRadius * s.BossPresenceRadius;
			int num2 = 0;
			for (int i = 0; i < players.Count; i++)
			{
				PlayerSample playerSample = players[i];
				if (playerSample.Connected && playerSample.Alive)
				{
					float num3 = playerSample.X - altarX;
					float num4 = playerSample.Y - altarY;
					float num5 = playerSample.Z - altarZ;
					if (!(num3 * num3 + num4 * num4 + num5 * num5 > num))
					{
						num2++;
						presentIds?.Add(playerSample.Id);
					}
				}
			}
			return num2;
		}

		public static BossDecision Evaluate(DalSettings s, float altarX, float altarY, float altarZ, long summonerId, IList<PlayerSample> players)
		{
			int minPlayersForBoss = s.MinPlayersForBoss;
			if (minPlayersForBoss <= 1)
			{
				return new BossDecision
				{
					Allowed = true,
					Present = 1,
					Needed = minPlayersForBoss
				};
			}
			float num = s.BossPresenceRadius * s.BossPresenceRadius;
			int num2 = 0;
			bool flag = false;
			for (int i = 0; i < players.Count; i++)
			{
				PlayerSample playerSample = players[i];
				if (!playerSample.Connected || !playerSample.Alive)
				{
					continue;
				}
				float num3 = playerSample.X - altarX;
				float num4 = playerSample.Y - altarY;
				float num5 = playerSample.Z - altarZ;
				if (!(num3 * num3 + num4 * num4 + num5 * num5 > num))
				{
					num2++;
					if (playerSample.Id == summonerId)
					{
						flag = true;
					}
				}
			}
			bool flag2 = num2 >= minPlayersForBoss && flag;
			return new BossDecision
			{
				Allowed = flag2,
				Present = num2,
				Needed = minPlayersForBoss,
				Message = (flag2 ? null : ("The altar stays silent. You need " + minPlayersForBoss + " players nearby."))
			};
		}
	}
	public struct CompassTick
	{
		public float Offset;

		public string Label;

		public bool Major;
	}
	public static class CompassMath
	{
		private static readonly string[] Names = new string[8] { "N", "NE", "E", "SE", "S", "SW", "W", "NW" };

		public static float Normalize(float deg)
		{
			deg %= 360f;
			if (!(deg < 0f))
			{
				return deg;
			}
			return deg + 360f;
		}

		public static float Delta(float from, float target)
		{
			float num = Normalize(target - from);
			if (!(num > 180f))
			{
				return num;
			}
			return num - 360f;
		}

		public static string Cardinal(float deg)
		{
			int num = (int)Math.Round(Normalize(deg) / 45f) % 8;
			return Names[num];
		}

		public static List<CompassTick> Ticks(float heading, float halfSpan, float step)
		{
			List<CompassTick> list = new List<CompassTick>();
			for (float num = (float)Math.Ceiling((heading - halfSpan) / step) * step; num <= heading + halfSpan + 0.001f; num += step)
			{
				float num2 = Normalize(num);
				bool flag = Math.Abs(num2 % 45f) < 0.001f || Math.Abs(num2 % 45f - 45f) < 0.001f;
				list.Add(new CompassTick
				{
					Offset = num - heading,
					Label = (flag ? Cardinal(num2) : ""),
					Major = flag
				});
			}
			return list;
		}
	}
	public static class DalIds
	{
		public const string Guid = "com.laoch.droppedandlost";

		public const string Name = "Dropped and Lost";

		public const string Version = "0.2.2";

		public const int ProtocolVersion = 1;
	}
	public sealed class DalRandom
	{
		private ulong _state;

		public DalRandom(ulong seed)
		{
			_state = seed;
		}

		public static ulong Seed(ulong a, ulong b, ulong c)
		{
			DalRandom dalRandom = new DalRandom((ulong)(((long)a * -7046029254386353131L) ^ -3335678366873096957L));
			dalRandom._state ^= b;
			dalRandom.NextU64();
			dalRandom._state ^= c;
			dalRandom.NextU64();
			return dalRandom.NextU64();
		}

		public static ulong HashString(string s)
		{
			ulong num = 14695981039346656037uL;
			string text = s ?? "";
			foreach (char c in text)
			{
				num ^= c;
				num *= 1099511628211L;
			}
			return num;
		}

		public ulong NextU64()
		{
			_state += 11400714819323198485uL;
			ulong state = _state;
			long num = (long)(state ^ (state >> 30)) * -4658895280553007687L;
			long num2 = (num ^ (num >>> 27)) * -7723592293110705685L;
			return (ulong)(num2 ^ (num2 >>> 31));
		}

		public double NextDouble()
		{
			return (double)(NextU64() >> 11) * 1.1102230246251565E-16;
		}

		public int NextInt(int exclusiveMax)
		{
			return (int)(NextU64() % (ulong)exclusiveMax);
		}
	}
	public enum RespawnMode
	{
		FirstSpawn,
		Stones,
		RandomEachDeath
	}
	public sealed class DalSettings
	{
		public bool SpawnEnabled = true;

		public float SpawnMinDistance = 3000f;

		public float SpawnMaxDistance = 6000f;

		public float NearbyBiomeRadius = 150f;

		public int MinNearbyBiomes = 1;

		public int MaxSearchAttempts = 500;

		public float MaxSlopeDegrees = 20f;

		public float MinHeightAboveWater = 2f;

		public float MinDistanceFromLocations = 75f;

		public float MinDistanceFromOtherSpawns = 500f;

		public float MinMeadowsRadius = 120f;

		public float MinMeadowsFraction = 0.8f;

		public RespawnMode RespawnMode;

		public int RespawnRerollAfterDeaths;

		public bool NoMap = true;

		public bool DisableCartographyTable = true;

		public int MinPlayersForBoss = 2;

		public float BossPresenceRadius = 50f;

		public bool DisableShout = true;

		public bool BlockPings = true;

		public bool ShowJoinMessage = true;

		public bool AnnouncePresence = true;

		public string ArrivedText = "{0} has arrived.";

		public string LeftText = "{0} has left.";

		public string JoinMessage = "You are lost. Find friends. Bosses need company.";

		public bool LimitPortals = true;

		public int MaxPortalsPerPlayer = 2;

		public bool LockPortalNames = true;

		public bool ProtectFromOthers = true;

		public bool TombstoneHint = true;

		public string ForcedKeys = "";

		public bool EnforceMods;

		public float ModGraceSeconds = 20f;

		public bool DebugLogging;

		public DalSettings Clone()
		{
			return (DalSettings)MemberwiseClone();
		}

		public DalSettings Validated(List<string> warnings)
		{
			DalSettings dalSettings = new DalSettings();
			DalSettings dalSettings2 = Clone();
			if (!(dalSettings2.SpawnMinDistance >= 0f) || !(dalSettings2.SpawnMaxDistance > dalSettings2.SpawnMinDistance) || float.IsInfinity(dalSettings2.SpawnMaxDistance))
			{
				Warn("Spawn.MinDistance (" + dalSettings2.SpawnMinDistance + ") must be >= 0 and lower than Spawn.MaxDistance (" + dalSettings2.SpawnMaxDistance + "); both reset to defaults.");
				dalSettings2.SpawnMinDistance = dalSettings.SpawnMinDistance;
				dalSettings2.SpawnMaxDistance = dalSettings.SpawnMaxDistance;
			}
			if (!(dalSettings2.NearbyBiomeRadius >= 0f))
			{
				Warn("Spawn.NearbyBiomeRadius reset.");
				dalSettings2.NearbyBiomeRadius = dalSettings.NearbyBiomeRadius;
			}
			if (dalSettings2.MinNearbyBiomes < 0 || dalSettings2.MinNearbyBiomes > 8)
			{
				Warn("Spawn.MinNearbyBiomes reset.");
				dalSettings2.MinNearbyBiomes = dalSettings.MinNearbyBiomes;
			}
			if (dalSettings2.MaxSearchAttempts < 1)
			{
				Warn("Spawn.MaxSearchAttempts reset.");
				dalSettings2.MaxSearchAttempts = dalSettings.MaxSearchAttempts;
			}
			if (!(dalSettings2.MaxSlopeDegrees > 0f) || !(dalSettings2.MaxSlopeDegrees <= 90f))
			{
				Warn("Spawn.MaxSlopeDegrees reset.");
				dalSettings2.MaxSlopeDegrees = dalSettings.MaxSlopeDegrees;
			}
			if (!(dalSettings2.MinHeightAboveWater >= 0f))
			{
				Warn("Spawn.MinHeightAboveWater reset.");
				dalSettings2.MinHeightAboveWater = dalSettings.MinHeightAboveWater;
			}
			if (!(dalSettings2.MinMeadowsRadius >= 0f) || !(dalSettings2.MinMeadowsRadius <= 1000f))
			{
				Warn("Spawn.MinMeadowsRadius must be 0-1000; reset.");
				dalSettings2.MinMeadowsRadius = dalSettings.MinMeadowsRadius;
			}
			if (!(dalSettings2.MinMeadowsFraction >= 0f) || !(dalSettings2.MinMeadowsFraction <= 1f))
			{
				Warn("Spawn.MinMeadowsFraction must be 0-1; reset.");
				dalSettings2.MinMeadowsFraction = dalSettings.MinMeadowsFraction;
			}
			if (!(dalSettings2.MinDistanceFromLocations >= 0f))
			{
				Warn("Spawn.MinDistanceFromLocations reset.");
				dalSettings2.MinDistanceFromLocations = dalSettings.MinDistanceFromLocations;
			}
			if (!(dalSettings2.MinDistanceFromOtherSpawns >= 0f) || float.IsInfinity(dalSettings2.MinDistanceFromOtherSpawns))
			{
				Warn("Spawn.MinDistanceFromOtherSpawns reset.");
				dalSettings2.MinDistanceFromOtherSpawns = dalSettings.MinDistanceFromOtherSpawns;
			}
			if (dalSettings2.RespawnRerollAfterDeaths < 0)
			{
				Warn("Respawn.RerollAfterDeaths reset.");
				dalSettings2.RespawnRerollAfterDeaths = dalSettings.RespawnRerollAfterDeaths;
			}
			if (dalSettings2.MinPlayersForBoss < 1)
			{
				Warn("Boss.MinPlayersForBoss must be >= 1; reset.");
				dalSettings2.MinPlayersForBoss = dalSettings.MinPlayersForBoss;
			}
			if (!(dalSettings2.BossPresenceRadius > 0f))
			{
				Warn("Boss.PresenceRadius reset.");
				dalSettings2.BossPresenceRadius = dalSettings.BossPresenceRadius;
			}
			if (dalSettings2.MaxPortalsPerPlayer < 1)
			{
				Warn("Portals.MaxPortalsPerPlayer must be >= 1; reset.");
				dalSettings2.MaxPortalsPerPlayer = dalSettings.MaxPortalsPerPlayer;
			}
			if (!(dalSettings2.ModGraceSeconds >= 5f) || !(dalSettings2.ModGraceSeconds <= 600f))
			{
				Warn("Mods.GraceSeconds must be 5-600; reset.");
				dalSettings2.ModGraceSeconds = dalSettings.ModGraceSeconds;
			}
			if (dalSettings2.JoinMessage == null)
			{
				dalSettings2.JoinMessage = dalSettings.JoinMessage;
			}
			if (string.IsNullOrWhiteSpace(dalSettings2.ArrivedText) || dalSettings2.ArrivedText.Length > 120)
			{
				dalSettings2.ArrivedText = dalSettings.ArrivedText;
			}
			if (string.IsNullOrWhiteSpace(dalSettings2.LeftText) || dalSettings2.LeftText.Length > 120)
			{
				dalSettings2.LeftText = dalSettings.LeftText;
			}
			return dalSettings2;
			void Warn(string m)
			{
				if (warnings != null)
				{
					warnings.Add(m);
				}
			}
		}
	}
	public static class ForcedKeys
	{
		public const int MaxEntries = 32;

		public static List<string> Parse(string raw, List<string> warnings)
		{
			List<string> list = new List<string>();
			HashSet<string> hashSet = new HashSet<string>(StringComparer.Ordinal);
			if (string.IsNullOrWhiteSpace(raw))
			{
				return list;
			}
			string[] array = raw.Split(new char[4] { ';', ',', '\n', '\r' }, StringSplitOptions.RemoveEmptyEntries);
			foreach (string text in array)
			{
				string text2 = string.Join(" ", text.Trim().Split(new char[2] { ' ', '\t' }, StringSplitOptions.RemoveEmptyEntries)).ToLowerInvariant();
				if (text2.Length == 0)
				{
					continue;
				}
				bool flag = false;
				string text3 = text2;
				for (int j = 0; j < text3.Length; j++)
				{
					if (char.IsControl(text3[j]))
					{
						flag = true;
						break;
					}
				}
				if (flag)
				{
					warnings?.Add("World.ForcedKeys: ignored an entry with control characters.");
					continue;
				}
				string text4 = KeyName(text2);
				if (!hashSet.Add(text4))
				{
					warnings?.Add("World.ForcedKeys: '" + text4 + "' listed twice; the first one is used.");
					continue;
				}
				if (list.Count >= 32)
				{
					warnings?.Add("World.ForcedKeys: only the first " + 32 + " entries are used.");
					break;
				}
				list.Add(text2);
			}
			return list;
		}

		public static string KeyName(string entry)
		{
			int num = entry.IndexOf(' ');
			if (num <= 0)
			{
				return entry;
			}
			return entry.Substring(0, num);
		}

		public static List<string> Merge(IEnumerable<string> worldKeys, IList<string> forced)
		{
			HashSet<string> hashSet = new HashSet<string>(StringComparer.Ordinal);
			foreach (string item in forced)
			{
				hashSet.Add(KeyName(item));
			}
			List<string> list = new List<string>();
			foreach (string worldKey in worldKeys)
			{
				if (!hashSet.Contains(KeyName((worldKey ?? "").ToLowerInvariant())))
				{
					list.Add(worldKey);
				}
			}
			list.AddRange(forced);
			return list;
		}
	}
	public static class GraveHint
	{
		private static readonly string[] Words = new string[8] { "north", "north-east", "east", "south-east", "south", "south-west", "west", "north-west" };

		public static float BearingDegrees(float fromX, float fromZ, float toX, float toZ)
		{
			return CompassMath.Normalize((float)(Math.Atan2(toX - fromX, toZ - fromZ) * 180.0 / Math.PI));
		}

		public static string Distance(float metres)
		{
			if (metres < 100f)
			{
				return (int)(Math.Round(metres / 10f) * 10.0) + " m";
			}
			if (metres < 1000f)
			{
				return (int)(Math.Round(metres / 50f) * 50.0) + " m";
			}
			return (Math.Round(metres / 100f) / 10.0).ToString("0.0", CultureInfo.InvariantCulture) + " km";
		}

		public static string Describe(float fromX, float fromZ, float toX, float toZ)
		{
			float num = toX - fromX;
			float num2 = toZ - fromZ;
			float num3 = (float)Math.Sqrt(num * num + num2 * num2);
			if (num3 < 15f)
			{
				return "Your grave is right here.";
			}
			int num4 = (int)Math.Round(BearingDegrees(fromX, fromZ, toX, toZ) / 45f) % 8;
			return "Your grave lies about " + Distance(num3) + " to the " + Words[num4] + ".";
		}
	}
	public struct ReportedMod
	{
		public string Guid;

		public string Version;

		public string Hash;
	}
	public sealed class ModVerdict
	{
		public readonly List<string> Extra = new List<string>();

		public readonly List<string> WrongVersion = new List<string>();

		public readonly List<string> WrongHash = new List<string>();

		public readonly List<string> Missing = new List<string>();

		public bool Ok
		{
			get
			{
				if (Extra.Count == 0 && WrongVersion.Count == 0 && WrongHash.Count == 0)
				{
					return Missing.Count == 0;
				}
				return false;
			}
		}

		public string Describe()
		{
			StringBuilder stringBuilder = new StringBuilder();
			Part(stringBuilder, "not allowed", Extra);
			Part(stringBuilder, "wrong version", WrongVersion);
			Part(stringBuilder, "modified file", WrongHash);
			Part(stringBuilder, "missing", Missing);
			if (stringBuilder.Length != 0)
			{
				return stringBuilder.ToString();
			}
			return "ok";
		}

		private static void Part(StringBuilder sb, string label, List<string> items)
		{
			if (items.Count == 0)
			{
				return;
			}
			if (sb.Length > 0)
			{
				sb.Append("; ");
			}
			sb.Append(label).Append(": ");
			for (int i = 0; i < items.Count && i < 4; i++)
			{
				if (i > 0)
				{
					sb.Append(", ");
				}
				sb.Append(items[i]);
			}
			if (items.Count > 4)
			{
				sb.Append(" (+").Append(items.Count - 4).Append(" more)");
			}
		}
	}
	public sealed class ModPolicy
	{
		private sealed class Rule
		{
			public string Version;

			public string Hash;

			public bool Required;
		}

		private readonly Dictionary<string, Rule> _rules = new Dictionary<string, Rule>(StringComparer.OrdinalIgnoreCase);

		public int Count => _rules.Count;

		public static ModPolicy Parse(string text, IEnumerable<string> alwaysAllowed, IEnumerable<string> alwaysRequired, List<string> warnings)
		{
			ModPolicy modPolicy = new ModPolicy();
			if (alwaysAllowed != null)
			{
				foreach (string item in alwaysAllowed)
				{
					modPolicy._rules[item] = new Rule();
				}
			}
			if (alwaysRequired != null)
			{
				foreach (string item2 in alwaysRequired)
				{
					modPolicy._rules[item2] = new Rule
					{
						Required = true
					};
				}
			}
			if (string.IsNullOrEmpty(text))
			{
				return modPolicy;
			}
			int num = 0;
			string[] array = text.Split(new char[1] { '\n' });
			foreach (string obj in array)
			{
				num++;
				string text2 = obj.Trim();
				int num2 = text2.IndexOf('#');
				if (num2 >= 0)
				{
					text2 = text2.Substring(0, num2).Trim();
				}
				if (text2.Length == 0)
				{
					continue;
				}
				bool flag = false;
				if (text2[0] == '+')
				{
					flag = true;
					text2 = text2.Substring(1).Trim();
				}
				string[] array2 = text2.Split(new char[1] { '|' });
				string text3 = array2[0].Trim();
				if (text3.Length == 0)
				{
					warnings?.Add("Mod list line " + num + " has no mod id; skipped.");
					continue;
				}
				string text4 = ((array2.Length > 1) ? array2[1].Trim() : "");
				string text5 = ((array2.Length > 2) ? array2[2].Trim().ToLowerInvariant() : "");
				if (array2.Length > 3)
				{
					warnings?.Add("Mod list line " + num + " has extra fields; ignored.");
				}
				Rule value;
				bool required = flag || (modPolicy._rules.TryGetValue(text3, out value) && value.Required);
				modPolicy._rules[text3] = new Rule
				{
					Version = ((text4.Length == 0 || text4 == "*") ? null : text4),
					Hash = ((text5.Length == 0) ? null : text5),
					Required = required
				};
			}
			return modPolicy;
		}

		public ModVerdict Evaluate(IEnumerable<ReportedMod> reported)
		{
			ModVerdict modVerdict = new ModVerdict();
			HashSet<string> hashSet = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
			foreach (ReportedMod item in reported)
			{
				string text = item.Guid ?? "";
				hashSet.Add(text);
				if (!_rules.TryGetValue(text, out var value))
				{
					modVerdict.Extra.Add(text);
					continue;
				}
				if (value.Version != null && !string.Equals(value.Version, item.Version, StringComparison.OrdinalIgnoreCase))
				{
					modVerdict.WrongVersion.Add(text + " " + item.Version + " (need " + value.Version + ")");
				}
				if (value.Hash != null && !string.Equals(value.Hash, item.Hash, StringComparison.OrdinalIgnoreCase))
				{
					modVerdict.WrongHash.Add(text);
				}
			}
			foreach (KeyValuePair<string, Rule> rule in _rules)
			{
				if (rule.Value.Required && !hashSet.Contains(rule.Key))
				{
					modVerdict.Missing.Add(rule.Key);
				}
			}
			return modVerdict;
		}
	}
	public sealed class PortalEntry
	{
		public string PortalId;

		public long OwnerId;

		public string Tag;
	}
	public struct PlacementResult
	{
		public bool Allowed;

		public string Tag;

		public bool Paired;

		public string Message;
	}
	public sealed class PortalLedger
	{
		private static readonly string[] Adjectives = new string[16]
		{
			"Ember", "Cinder", "Frost", "Raven", "Amber", "Iron", "Mist", "Ash", "Storm", "Pale",
			"Dusk", "Gilded", "Hollow", "Silent", "Wild", "Stone"
		};

		private static readonly string[] Nouns = new string[16]
		{
			"Hollow", "Marsh", "Ridge", "Fen", "Glade", "Crag", "Barrow", "Strand", "Moor", "Cairn",
			"Vale", "Tarn", "Reach", "Holt", "Ford", "Weald"
		};

		private readonly Dictionary<string, PortalEntry> _portals = new Dictionary<string, PortalEntry>();

		private readonly HashSet<string> _retired = new HashSet<string>();

		public readonly HashSet<string> Preexisting = new HashSet<string>();

		public bool Baselined;

		public int Count => _portals.Count;

		public IEnumerable<PortalEntry> Entries => _portals.Values;

		public bool TryGet(string portalId, out PortalEntry e)
		{
			return _portals.TryGetValue(portalId, out e);
		}

		public int CountOwned(long ownerId)
		{
			return _portals.Values.Count((PortalEntry p) => p.OwnerId == ownerId);
		}

		public PlacementResult OnPlaced(DalSettings s, long ownerId, string portalId, DalRandom rng)
		{
			if (_portals.TryGetValue(portalId, out var value))
			{
				return new PlacementResult
				{
					Allowed = true,
					Tag = value.Tag,
					Paired = (TagCount(value.Tag) >= 2)
				};
			}
			if (CountOwned(ownerId) >= s.MaxPortalsPerPlayer)
			{
				return new PlacementResult
				{
					Allowed = false,
					Message = "You already have " + s.MaxPortalsPerPlayer + " portals standing."
				};
			}
			string text = null;
			foreach (IGrouping<string, PortalEntry> item in from p in _portals.Values
				where p.OwnerId == ownerId
				group p by p.Tag)
			{
				if (item.Count() == 1)
				{
					text = item.Key;
					break;
				}
			}
			bool paired = text != null;
			if (text == null)
			{
				text = NewTag(rng);
			}
			_portals[portalId] = new PortalEntry
			{
				PortalId = portalId,
				OwnerId = ownerId,
				Tag = text
			};
			return new PlacementResult
			{
				Allowed = true,
				Tag = text,
				Paired = paired
			};
		}

		public void OnRemoved(string portalId)
		{
			if (_portals.TryGetValue(portalId, out var value))
			{
				_portals.Remove(portalId);
				if (TagCount(value.Tag) == 0)
				{
					_retired.Add(value.Tag);
				}
			}
		}

		public bool Replace(string oldId, string newId)
		{
			if (!_portals.TryGetValue(oldId, out var value) || _portals.ContainsKey(newId))
			{
				return false;
			}
			_portals.Remove(oldId);
			value.PortalId = newId;
			_portals[newId] = value;
			return true;
		}

		public int Reconcile(ICollection<string> livePortalIds)
		{
			List<string> list = _portals.Keys.Where((string k) => !livePortalIds.Contains(k)).ToList();
			foreach (string item in list)
			{
				OnRemoved(item);
			}
			return list.Count;
		}

		public bool MayRemove(DalSettings s, string portalId, long actorId)
		{
			if (!s.LimitPortals || !s.ProtectFromOthers)
			{
				return true;
			}
			if (!_portals.TryGetValue(portalId, out var value))
			{
				return true;
			}
			return value.OwnerId == actorId;
		}

		public bool TagMatches(string portalId, string tag)
		{
			if (_portals.TryGetValue(portalId, out var value))
			{
				return string.Equals(value.Tag, tag, StringComparison.Ordinal);
			}
			return false;
		}

		private int TagCount(string tag)
		{
			return _portals.Values.Count((PortalEntry p) => p.Tag == tag);
		}

		private string NewTag(DalRandom rng)
		{
			for (int i = 0; i < 10000; i++)
			{
				string text = Adjectives[rng.NextInt(Adjectives.Length)] + "-" + Nouns[rng.NextInt(Nouns.Length)] + "-" + rng.NextInt(100).ToString(CultureInfo.InvariantCulture);
				if (!_retired.Contains(text) && TagCount(text) == 0)
				{
					return text;
				}
			}
			string text2;
			do
			{
				text2 = "Lost-" + rng.NextU64().ToString("x", CultureInfo.InvariantCulture);
			}
			while (_retired.Contains(text2) || TagCount(text2) != 0);
			return text2;
		}

		public string Serialize()
		{
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.Append("DALPORTAL 1\n");
			if (Baselined)
			{
				stringBuilder.Append("B\n");
			}
			foreach (string item in Preexisting)
			{
				stringBuilder.Append("X|").Append(item).Append('\n');
			}
			foreach (PortalEntry value in _portals.Values)
			{
				stringBuilder.Append("P|").Append(value.PortalId).Append('|')
					.Append(value.OwnerId.ToString(CultureInfo.InvariantCulture))
					.Append('|')
					.Append(value.Tag)
					.Append('\n');
			}
			foreach (string item2 in _retired)
			{
				stringBuilder.Append("R|").Append(item2).Append('\n');
			}
			return stringBuilder.ToString();
		}

		public static PortalLedger Deserialize(string text, out string error)
		{
			error = null;
			PortalLedger portalLedger = new PortalLedger();
			string[] array = (text ?? "").Split(new char[1] { '\n' }, StringSplitOptions.RemoveEmptyEntries);
			if (array.Length == 0 || array[0].Trim() != "DALPORTAL 1")
			{
				error = "unrecognised portal ledger header";
				return null;
			}
			for (int i = 1; i < array.Length; i++)
			{
				string[] array2 = array[i].Trim().Split(new char[1] { '|' });
				if (array2[0] == "B" && array2.Length == 1)
				{
					portalLedger.Baselined = true;
				}
				else if (array2[0] == "X" && array2.Length == 2)
				{
					portalLedger.Preexisting.Add(array2[1]);
				}
				else if (array2[0] == "P" && array2.Length == 4)
				{
					if (!long.TryParse(array2[2], NumberStyles.Integer, CultureInfo.InvariantCulture, out var result))
					{
						error = "bad owner on line " + (i + 1);
						return null;
					}
					portalLedger._portals[array2[1]] = new PortalEntry
					{
						PortalId = array2[1],
						OwnerId = result,
						Tag = array2[3]
					};
				}
				else
				{
					if (!(array2[0] == "R") || array2.Length != 2)
					{
						error = "bad portal ledger line " + (i + 1);
						return null;
					}
					portalLedger._retired.Add(array2[1]);
				}
			}
			return portalLedger;
		}
	}
	public sealed class SpawnRecord
	{
		public string Key;

		public float X;

		public float Z;

		public bool HasPoint;

		public int Rolls;

		public int DeathsNoBed;

		public bool VanillaFallback;

		public bool Spawned;
	}
	public enum RespawnAction
	{
		UseAssigned,
		UseStones,
		RollNew
	}
	public sealed class SpawnLedger
	{
		private readonly Dictionary<string, SpawnRecord> _records = new Dictionary<string, SpawnRecord>();

		public HashSet<string> LegacyAccounts = new HashSet<string>(StringComparer.Ordinal);

		public IEnumerable<SpawnRecord> Records => _records.Values;

		public bool TryGet(string playerId, out SpawnRecord r)
		{
			return _records.TryGetValue(playerId, out r);
		}

		public bool Forget(string playerId)
		{
			return _records.Remove(playerId);
		}

		public SpawnRecord GetOrCreate(string playerId)
		{
			if (!_records.TryGetValue(playerId, out var value))
			{
				value = new SpawnRecord
				{
					Key = playerId
				};
				_records[playerId] = value;
			}
			return value;
		}

		public void Assign(string playerId, SpawnPoint p)
		{
			SpawnRecord orCreate = GetOrCreate(playerId);
			orCreate.X = p.X;
			orCreate.Z = p.Z;
			orCreate.HasPoint = true;
			orCreate.VanillaFallback = false;
			orCreate.Rolls++;
			orCreate.DeathsNoBed = 0;
		}

		public void AssignVanillaFallback(string playerId)
		{
			SpawnRecord orCreate = GetOrCreate(playerId);
			orCreate.HasPoint = false;
			orCreate.VanillaFallback = true;
			orCreate.Rolls++;
			orCreate.DeathsNoBed = 0;
		}

		public RespawnAction OnDeathWithoutBed(string playerId, DalSettings s)
		{
			SpawnRecord orCreate = GetOrCreate(playerId);
			orCreate.DeathsNoBed++;
			switch (s.RespawnMode)
			{
			case RespawnMode.Stones:
				return RespawnAction.UseStones;
			case RespawnMode.RandomEachDeath:
				return RespawnAction.RollNew;
			default:
				if (s.RespawnRerollAfterDeaths > 0 && orCreate.DeathsNoBed >= s.RespawnRerollAfterDeaths)
				{
					return RespawnAction.RollNew;
				}
				if (!orCreate.HasPoint)
				{
					return RespawnAction.UseStones;
				}
				return RespawnAction.UseAssigned;
			}
		}

		public void OnBedRespawn(string playerId)
		{
			if (_records.TryGetValue(playerId, out var value))
			{
				value.DeathsNoBed = 0;
			}
		}

		public string Serialize()
		{
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.Append("DALSPAWN 1\n");
			foreach (string legacyAccount in LegacyAccounts)
			{
				stringBuilder.Append("L|").Append(Uri.EscapeDataString(legacyAccount)).Append('\n');
			}
			foreach (SpawnRecord value in _records.Values)
			{
				stringBuilder.Append("S|").Append(Uri.EscapeDataString(value.Key)).Append('|')
					.Append(value.HasPoint ? 1 : 0)
					.Append('|')
					.Append(value.X.ToString("R", CultureInfo.InvariantCulture))
					.Append('|')
					.Append(value.Z.ToString("R", CultureInfo.InvariantCulture))
					.Append('|')
					.Append(value.Rolls)
					.Append('|')
					.Append(value.DeathsNoBed)
					.Append('|')
					.Append(value.VanillaFallback ? 1 : 0)
					.Append('|')
					.Append(value.Spawned ? 1 : 0)
					.Append('\n');
			}
			return stringBuilder.ToString();
		}

		public static SpawnLedger Deserialize(string text, out string error)
		{
			error = null;
			SpawnLedger spawnLedger = new SpawnLedger();
			string[] array = (text ?? "").Split(new char[1] { '\n' }, StringSplitOptions.RemoveEmptyEntries);
			if (array.Length == 0 || array[0].Trim() != "DALSPAWN 1")
			{
				error = "unrecognised spawn ledger header";
				return null;
			}
			for (int i = 1; i < array.Length; i++)
			{
				string[] array2 = array[i].Trim().Split(new char[1] { '|' });
				if (array2.Length == 2 && array2[0] == "L")
				{
					spawnLedger.LegacyAccounts.Add(Uri.UnescapeDataString(array2[1]));
					continue;
				}
				if (array2.Length != 9 || array2[0] != "S")
				{
					error = "bad spawn ledger line " + (i + 1);
					return null;
				}
				try
				{
					SpawnRecord spawnRecord = new SpawnRecord
					{
						Key = Uri.UnescapeDataString(array2[1]),
						HasPoint = (array2[2] == "1"),
						X = float.Parse(array2[3], CultureInfo.InvariantCulture),
						Z = float.Parse(array2[4], CultureInfo.InvariantCulture),
						Rolls = int.Parse(array2[5], CultureInfo.InvariantCulture),
						DeathsNoBed = int.Parse(array2[6], CultureInfo.InvariantCulture),
						VanillaFallback = (array2[7] == "1"),
						Spawned = (array2[8] == "1")
					};
					spawnLedger._records[spawnRecord.Key] = spawnRecord;
				}
				catch (FormatException)
				{
					error = "bad number on spawn ledger line " + (i + 1);
					return null;
				}
			}
			return spawnLedger;
		}
	}
	public interface ITerrain
	{
		bool IsMeadows(float x, float z);

		float HeightAboveWater(float x, float z);

		float SlopeDegrees(float x, float z);

		int OtherBiomesWithin(float x, float z, float radius);

		float DistanceToNearestLocation(float x, float z);

		float MeadowsFractionWithin(float x, float z, float radius);
	}
	public struct SpawnPoint
	{
		public float X;

		public float Z;

		public SpawnPoint(float x, float z)
		{
			X = x;
			Z = z;
		}
	}
	public struct SearchStage
	{
		public float MinDistance;

		public float MaxDistance;

		public float NearbyRadius;

		public float MeadowsRadius;

		public float Spacing;

		public int MinNearbyBiomes;

		public string Label;
	}
	public enum SearchState
	{
		InProgress,
		Found,
		Exhausted
	}
	public sealed class SpawnSearch
	{
		private readonly DalSettings _s;

		private readonly DalRandom _rng;

		private readonly SpawnPoint _origin;

		private readonly List<SearchStage> _stages;

		private int _stage;

		private int _attemptsInStage;

		private readonly IList<SpawnPoint> _others;

		public SpawnPoint Result { get; private set; }

		public int TotalAttempts { get; private set; }

		public int StageIndex => _stage;

		public IReadOnlyList<SearchStage> Stages => _stages;

		public string StageLabel => _stages[Math.Min(_stage, _stages.Count - 1)].Label;

		public SpawnSearch(DalSettings settings, DalRandom rng, SpawnPoint origin, IList<SpawnPoint> others = null)
		{
			_s = settings;
			_rng = rng;
			_origin = origin;
			_others = ((others != null && others.Count > 0) ? others : null);
			_stages = BuildStages(settings, _others != null);
		}

		public static List<SearchStage> BuildStages(DalSettings s)
		{
			return BuildStages(s, hasOthers: false);
		}

		public static List<SearchStage> BuildStages(DalSettings s, bool hasOthers)
		{
			List<SearchStage> list = new List<SearchStage>();
			float spawnMinDistance = s.SpawnMinDistance;
			float spawnMaxDistance = s.SpawnMaxDistance;
			float num = s.NearbyBiomeRadius;
			float minMeadowsRadius = s.MinMeadowsRadius;
			int num2 = s.MinNearbyBiomes;
			if (hasOthers && s.MinDistanceFromOtherSpawns > 0f)
			{
				list.Add(new SearchStage
				{
					MinDistance = spawnMinDistance,
					MaxDistance = spawnMaxDistance,
					NearbyRadius = num,
					MeadowsRadius = minMeadowsRadius,
					MinNearbyBiomes = num2,
					Spacing = s.MinDistanceFromOtherSpawns,
					Label = "base, spacing " + s.MinDistanceFromOtherSpawns.ToString("F0") + "m"
				});
				list.Add(new SearchStage
				{
					MinDistance = spawnMinDistance,
					MaxDistance = spawnMaxDistance,
					NearbyRadius = num,
					MeadowsRadius = minMeadowsRadius,
					MinNearbyBiomes = num2,
					Spacing = s.MinDistanceFromOtherSpawns * 0.5f,
					Label = "base, spacing " + (s.MinDistanceFromOtherSpawns * 0.5f).ToString("F0") + "m"
				});
			}
			list.Add(new SearchStage
			{
				MinDistance = spawnMinDistance,
				MaxDistance = spawnMaxDistance,
				NearbyRadius = num,
				MeadowsRadius = minMeadowsRadius,
				MinNearbyBiomes = num2,
				Label = "base"
			});
			while (num2 > 0)
			{
				num2--;
				list.Add(new SearchStage
				{
					MinDistance = spawnMinDistance,
					MaxDistance = spawnMaxDistance,
					NearbyRadius = num,
					MeadowsRadius = minMeadowsRadius,
					MinNearbyBiomes = num2,
					Label = "nearby-biomes=" + num2
				});
			}
			if (num2 > 0)
			{
				num *= 2f;
				list.Add(new SearchStage
				{
					MinDistance = spawnMinDistance,
					MaxDistance = spawnMaxDistance,
					NearbyRadius = num,
					MeadowsRadius = minMeadowsRadius,
					MinNearbyBiomes = num2,
					Label = "nearby-radius x2"
				});
			}
			float minDistance = ((spawnMinDistance <= 1000f) ? spawnMinDistance : Math.Max(1000f, spawnMinDistance - 500f));
			list.Add(new SearchStage
			{
				MinDistance = minDistance,
				MaxDistance = spawnMaxDistance + 500f,
				NearbyRadius = num,
				MeadowsRadius = minMeadowsRadius * 0.5f,
				MinNearbyBiomes = num2,
				Label = "band widened 500m, meadows size halved"
			});
			return list;
		}

		public static SpawnPoint Sample(DalRandom rng, SpawnPoint origin, float min, float max)
		{
			double num = rng.NextDouble() * 2.0 * Math.PI;
			double num2 = Math.Sqrt(rng.NextDouble() * ((double)max * (double)max - (double)min * (double)min) + (double)min * (double)min);
			return new SpawnPoint(origin.X + (float)(Math.Cos(num) * num2), origin.Z + (float)(Math.Sin(num) * num2));
		}

		public SearchState Step(ITerrain t, int maxCandidates)
		{
			for (int i = 0; i < maxCandidates; i++)
			{
				if (_stage >= _stages.Count)
				{
					return SearchState.Exhausted;
				}
				if (_attemptsInStage >= _s.MaxSearchAttempts)
				{
					_stage++;
					_attemptsInStage = 0;
					continue;
				}
				SearchStage st = _stages[_stage];
				SpawnPoint spawnPoint = Sample(_rng, _origin, st.MinDistance, st.MaxDistance);
				_attemptsInStage++;
				TotalAttempts++;
				if (Passes(t, spawnPoint, st))
				{
					Result = spawnPoint;
					return SearchState.Found;
				}
			}
			if (_stage < _stages.Count)
			{
				return SearchState.InProgress;
			}
			return SearchState.Exhausted;
		}

		private bool Passes(ITerrain t, SpawnPoint p, SearchStage st)
		{
			if (st.Spacing > 0f && _others != null)
			{
				float num = st.Spacing * st.Spacing;
				for (int i = 0; i < _others.Count; i++)
				{
					float num2 = p.X - _others[i].X;
					float num3 = p.Z - _others[i].Z;
					if (num2 * num2 + num3 * num3 < num)
					{
						return false;
					}
				}
			}
			if (!t.IsMeadows(p.X, p.Z))
			{
				return false;
			}
			if (t.HeightAboveWater(p.X, p.Z) < _s.MinHeightAboveWater)
			{
				return false;
			}
			if (t.SlopeDegrees(p.X, p.Z) > _s.MaxSlopeDegrees)
			{
				return false;
			}
			if (st.MeadowsRadius > 0f && t.MeadowsFractionWithin(p.X, p.Z, st.MeadowsRadius) < _s.MinMeadowsFraction)
			{
				return false;
			}
			if (st.MinNearbyBiomes > 0 && t.OtherBiomesWithin(p.X, p.Z, st.NearbyRadius) < st.MinNearbyBiomes)
			{
				return false;
			}
			if (t.DistanceToNearestLocation(p.X, p.Z) < _s.MinDistanceFromLocations)
			{
				return false;
			}
			return true;
		}

		public SearchState RunToEnd(ITerrain t)
		{
			SearchState searchState;
			do
			{
				searchState = Step(t, 65536);
			}
			while (searchState == SearchState.InProgress);
			return searchState;
		}
	}
}