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

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.0", FrameworkDisplayName = ".NET Standard 2.0")]
[assembly: AssemblyCompany("DangerousRoads.Core")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("0.1.13.0")]
[assembly: AssemblyInformationalVersion("0.1.13+06e79d2edf3a19848f2e4105dddc16417cd2c1fe")]
[assembly: AssemblyProduct("DangerousRoads.Core")]
[assembly: AssemblyTitle("DangerousRoads.Core")]
[assembly: AssemblyMetadata("BuildStamp", "06e79d2e 2026-09-05")]
[assembly: AssemblyVersion("0.0.0.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class IsReadOnlyAttribute : Attribute
	{
	}
	[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 DangerousRoads.Core
{
	public readonly struct ClockState
	{
		public readonly bool Armed;

		public readonly double DueAt;

		public static readonly ClockState Disarmed = new ClockState(armed: false, 0.0);

		public ClockState(bool armed, double dueAt)
		{
			Armed = armed;
			DueAt = dueAt;
		}

		public override string ToString()
		{
			if (!Armed)
			{
				return "disarmed";
			}
			return $"armed@{DueAt:F1}";
		}
	}
	public static class AmbushClock
	{
		public static float NextDelay(double roll01, float min, float max)
		{
			if (min < 0f)
			{
				min = 0f;
			}
			if (max < 0f)
			{
				max = 0f;
			}
			if (max < min)
			{
				max = min;
			}
			if (roll01 < 0.0)
			{
				roll01 = 0.0;
			}
			if (roll01 > 1.0)
			{
				roll01 = 1.0;
			}
			return min + (float)((double)(max - min) * roll01);
		}

		public static ClockState Arm(double now, float delay)
		{
			return new ClockState(armed: true, now + (double)((delay < 0f) ? 0f : delay));
		}

		public static bool IsDue(ClockState state, double now)
		{
			if (state.Armed)
			{
				return now >= state.DueAt;
			}
			return false;
		}

		public static ClockState AfterWave(double now, float cooldownFloor, float rolledDelay)
		{
			return Arm(now, Math.Max(cooldownFloor, rolledDelay));
		}

		public static ClockState Retry(double now, float retrySeconds)
		{
			return Arm(now, retrySeconds);
		}
	}
	public static class BandMath
	{
		public const float MinCrowFlies = 0.5f;

		public static bool InBand(float distance, float min, float max)
		{
			if (distance >= min)
			{
				return distance <= max;
			}
			return false;
		}

		public static float Ratio(float pathLength, float crowFlies)
		{
			if (crowFlies < 0.5f)
			{
				return -1f;
			}
			if (pathLength < 0f)
			{
				return -1f;
			}
			return pathLength / crowFlies;
		}

		public static bool PathRatioOk(float pathLength, float crowFlies, float k)
		{
			if (k <= 0f)
			{
				return false;
			}
			float num = Ratio(pathLength, crowFlies);
			if (num < 0f)
			{
				return false;
			}
			return num <= k;
		}

		public static float Score(float distance, float ratio, float bandMin, float bandMax)
		{
			float num = bandMax - bandMin;
			float num2 = ((num <= 0f) ? 0f : ((distance - bandMin) / num));
			if (num2 < 0f)
			{
				num2 = 0f;
			}
			if (num2 > 1f)
			{
				num2 = 1f;
			}
			float num3 = 1f / Math.Max(1f, (ratio < 0f) ? float.MaxValue : ratio);
			return 0.6f * num2 + 0.4f * num3;
		}
	}
	public static class Bearing
	{
		private static readonly string[] Labels = new string[8] { "north", "north-east", "east", "south-east", "south", "south-west", "west", "north-west" };

		public static int Sector(float dx, float dz, float minDistance = 0.5f)
		{
			if (dx * dx + dz * dz < minDistance * minDistance)
			{
				return -1;
			}
			double num = Math.Atan2(dx, dz) * 180.0 / Math.PI;
			if (num < 0.0)
			{
				num += 360.0;
			}
			return (int)Math.Round(num / 45.0) % 8;
		}

		public static string Label(float dx, float dz, float minDistance = 0.5f)
		{
			int num = Sector(dx, dz, minDistance);
			if (num >= 0)
			{
				return Labels[num];
			}
			return "";
		}
	}
	public sealed class BlockCounters
	{
		private readonly Dictionary<string, int> _counts = new Dictionary<string, int>(StringComparer.OrdinalIgnoreCase);

		private readonly List<string> _order = new List<string>();

		public int Total { get; private set; }

		public string Last { get; private set; } = "(none)";

		public void Record(string reason)
		{
			string text = (Last = (string.IsNullOrWhiteSpace(reason) ? "(unknown)" : reason.Trim()));
			Total++;
			if (_counts.TryGetValue(text, out var value))
			{
				_counts[text] = value + 1;
				return;
			}
			_counts[text] = 1;
			_order.Add(text);
		}

		public void Reset()
		{
			_counts.Clear();
			_order.Clear();
			Total = 0;
			Last = "(none)";
		}

		public int CountOf(string reason)
		{
			if (!_counts.TryGetValue(reason ?? "", out var value))
			{
				return 0;
			}
			return value;
		}

		public string Format()
		{
			if (_counts.Count == 0)
			{
				return "none";
			}
			List<string> list = new List<string>(_order);
			list.Sort(delegate(string a, string b)
			{
				int num2 = _counts[b].CompareTo(_counts[a]);
				return (num2 == 0) ? _order.IndexOf(a).CompareTo(_order.IndexOf(b)) : num2;
			});
			StringBuilder stringBuilder = new StringBuilder();
			for (int num = 0; num < list.Count; num++)
			{
				if (num > 0)
				{
					stringBuilder.Append(' ');
				}
				stringBuilder.Append(list[num]).Append('=').Append(_counts[list[num]].ToString(CultureInfo.InvariantCulture));
			}
			return stringBuilder.ToString();
		}
	}
	public readonly struct CardArgs
	{
		private readonly Dictionary<string, string> _map;

		private readonly List<string> _positional;

		public static readonly CardArgs Empty = new CardArgs(null, null);

		public int Count
		{
			get
			{
				if (_map == null)
				{
					return 0;
				}
				return _map.Count;
			}
		}

		public IReadOnlyList<string> Positional
		{
			get
			{
				IReadOnlyList<string> positional = _positional;
				return positional ?? Array.Empty<string>();
			}
		}

		private CardArgs(Dictionary<string, string> map, List<string> positional)
		{
			_map = map;
			_positional = positional;
		}

		public static CardArgs Parse(IEnumerable<string> tokens)
		{
			if (tokens == null)
			{
				return Empty;
			}
			Dictionary<string, string> dictionary = null;
			List<string> list = null;
			foreach (string token in tokens)
			{
				if (string.IsNullOrEmpty(token))
				{
					continue;
				}
				string text = token.Trim();
				if (text.Length == 0)
				{
					continue;
				}
				int num = text.IndexOf('=');
				if (num <= 0)
				{
					(list ?? (list = new List<string>())).Add(text);
					continue;
				}
				string text2 = text.Substring(0, num).Trim();
				string value = text.Substring(num + 1).Trim();
				if (text2.Length == 0)
				{
					(list ?? (list = new List<string>())).Add(text);
				}
				else
				{
					(dictionary ?? (dictionary = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase)))[text2] = value;
				}
			}
			if (dictionary != null || list != null)
			{
				return new CardArgs(dictionary, list);
			}
			return Empty;
		}

		public bool Has(string key)
		{
			if (key != null && _map != null)
			{
				return _map.ContainsKey(key);
			}
			return false;
		}

		public string String(string key, string fallback)
		{
			if (key == null || _map == null || !_map.TryGetValue(key, out string value) || value.Length <= 0)
			{
				return fallback;
			}
			return value;
		}

		public float Float(string key, float fallback)
		{
			if (_map == null || key == null || !_map.TryGetValue(key, out string value) || !float.TryParse(value, NumberStyles.Float, CultureInfo.InvariantCulture, out var result) || float.IsNaN(result) || float.IsInfinity(result))
			{
				return fallback;
			}
			return result;
		}

		public int Int(string key, int fallback)
		{
			if (_map == null || key == null || !_map.TryGetValue(key, out string value) || !int.TryParse(value, NumberStyles.Integer, CultureInfo.InvariantCulture, out var result))
			{
				return fallback;
			}
			return result;
		}

		public bool Bool(string key, bool fallback)
		{
			if (_map == null || key == null || !_map.TryGetValue(key, out string value))
			{
				return fallback;
			}
			switch (value.ToLowerInvariant())
			{
			case "yes":
			case "on":
			case "1":
			case "true":
				return true;
			case "off":
			case "no":
			case "0":
			case "false":
				return false;
			default:
				return fallback;
			}
		}

		public List<string> Unknown(IEnumerable<string> known)
		{
			List<string> list = new List<string>();
			if (_map == null)
			{
				return list;
			}
			HashSet<string> hashSet = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
			if (known != null)
			{
				foreach (string item in known)
				{
					if (item != null)
					{
						hashSet.Add(item);
					}
				}
			}
			foreach (string key in _map.Keys)
			{
				if (!hashSet.Contains(key))
				{
					list.Add(key);
				}
			}
			list.Sort(StringComparer.OrdinalIgnoreCase);
			return list;
		}

		public string Describe()
		{
			if (_map == null && _positional == null)
			{
				return "(no args)";
			}
			StringBuilder stringBuilder = new StringBuilder();
			if (_map != null)
			{
				List<string> list = new List<string>(_map.Keys);
				list.Sort(StringComparer.OrdinalIgnoreCase);
				foreach (string item in list)
				{
					if (stringBuilder.Length > 0)
					{
						stringBuilder.Append(' ');
					}
					stringBuilder.Append(item).Append('=').Append(_map[item]);
				}
			}
			if (_positional != null)
			{
				foreach (string item2 in _positional)
				{
					if (stringBuilder.Length > 0)
					{
						stringBuilder.Append(' ');
					}
					stringBuilder.Append(item2);
				}
			}
			return stringBuilder.ToString();
		}

		public override string ToString()
		{
			return Describe();
		}
	}
	public interface ICardCondition
	{
		bool IsMet(WorldSnapshot world);

		string Describe();
	}
	public sealed class HourWindow : ICardCondition
	{
		public float From { get; }

		public float To { get; }

		public HourWindow(float fromHour, float toHour)
		{
			From = Wrap(fromHour);
			To = Wrap(toHour);
		}

		private static float Wrap(float h)
		{
			return (h % 24f + 24f) % 24f;
		}

		public bool IsMet(WorldSnapshot world)
		{
			if (world == null)
			{
				return false;
			}
			float hourOfDay = world.HourOfDay;
			if (From == To)
			{
				return true;
			}
			if (!(From < To))
			{
				if (!(hourOfDay >= From))
				{
					return hourOfDay < To;
				}
				return true;
			}
			if (hourOfDay >= From)
			{
				return hourOfDay < To;
			}
			return false;
		}

		public string Describe()
		{
			return $"hour={From:0.##}-{To:0.##}";
		}
	}
	public sealed class NightCondition : ICardCondition
	{
		public static readonly NightCondition Night = new NightCondition(wantNight: true);

		public static readonly NightCondition Day = new NightCondition(wantNight: false);

		public bool WantNight { get; }

		private NightCondition(bool wantNight)
		{
			WantNight = wantNight;
		}

		public bool IsMet(WorldSnapshot world)
		{
			if (world != null)
			{
				return world.IsNight == WantNight;
			}
			return false;
		}

		public string Describe()
		{
			if (!WantNight)
			{
				return "day";
			}
			return "night";
		}
	}
	public sealed class RainCondition : ICardCondition
	{
		public float Threshold { get; }

		public bool AtLeast { get; }

		public RainCondition(float threshold01, bool atLeast)
		{
			Threshold = ((threshold01 < 0f) ? 0f : ((threshold01 > 1f) ? 1f : threshold01));
			AtLeast = atLeast;
		}

		public bool IsMet(WorldSnapshot world)
		{
			if (world != null)
			{
				if (!AtLeast)
				{
					return world.Rain01 < Threshold;
				}
				return world.Rain01 >= Threshold;
			}
			return false;
		}

		public string Describe()
		{
			return "rain" + (AtLeast ? ">" : "<") + Threshold.ToString("0.##", CultureInfo.InvariantCulture);
		}
	}
	public sealed class QuestFlagCondition : ICardCondition
	{
		public string Flag { get; }

		public bool Present { get; }

		public QuestFlagCondition(string flag, bool present)
		{
			Flag = (flag ?? "").Trim();
			Present = present;
		}

		public bool IsMet(WorldSnapshot world)
		{
			if (world != null)
			{
				return world.HasFlag(Flag) == Present;
			}
			return false;
		}

		public string Describe()
		{
			return (Present ? "" : "!") + "flag:" + Flag;
		}
	}
	public sealed class FactionCondition : ICardCondition
	{
		public string Faction { get; }

		public FactionCondition(string faction)
		{
			Faction = (faction ?? "").Trim();
		}

		public bool IsMet(WorldSnapshot world)
		{
			if (world != null && Faction.Length > 0)
			{
				return world.PlayerFaction.IndexOf(Faction, StringComparison.OrdinalIgnoreCase) >= 0;
			}
			return false;
		}

		public string Describe()
		{
			return "faction:" + Faction;
		}
	}
	public sealed class RegionCondition : ICardCondition
	{
		public string Region { get; }

		public RegionCondition(string region)
		{
			Region = (region ?? "").Trim();
		}

		public bool IsMet(WorldSnapshot world)
		{
			if (world != null && Region.Length > 0)
			{
				return world.Region.IndexOf(Region, StringComparison.OrdinalIgnoreCase) >= 0;
			}
			return false;
		}

		public string Describe()
		{
			return "region:" + Region;
		}
	}
	public sealed class RoomWarmCondition : ICardCondition
	{
		public IReadOnlyList<string> Species { get; }

		public RoomWarmCondition(params string[] speciesKeys)
			: this((IEnumerable<string>)speciesKeys)
		{
		}

		public RoomWarmCondition(IEnumerable<string> speciesKeys)
		{
			List<string> list = new List<string>();
			if (speciesKeys != null)
			{
				foreach (string speciesKey in speciesKeys)
				{
					string text = (speciesKey ?? "").Trim();
					if (text.Length > 0)
					{
						list.Add(text);
					}
				}
			}
			Species = list;
		}

		public bool IsMet(WorldSnapshot world)
		{
			if (world == null)
			{
				return false;
			}
			if (Species.Count == 0)
			{
				return true;
			}
			for (int i = 0; i < Species.Count; i++)
			{
				if (world.IsRoomWarm(Species[i]))
				{
					return true;
				}
			}
			return false;
		}

		public string Describe()
		{
			return "roomwarm:" + string.Join(",", ToArray());
		}

		private string[] ToArray()
		{
			string[] array = new string[Species.Count];
			for (int i = 0; i < Species.Count; i++)
			{
				array[i] = Species[i];
			}
			return array;
		}
	}
	public sealed class ZoneCondition : ICardCondition
	{
		public static readonly ZoneCondition Overworld = new ZoneCondition(ZoneKind.Overworld);

		public static readonly ZoneCondition City = new ZoneCondition(ZoneKind.City);

		public static readonly ZoneCondition Dungeon = new ZoneCondition(ZoneKind.Dungeon);

		public ZoneKind Zone { get; }

		private ZoneCondition(ZoneKind zone)
		{
			Zone = zone;
		}

		public bool IsMet(WorldSnapshot world)
		{
			if (world != null)
			{
				return world.Zone == Zone;
			}
			return false;
		}

		public string Describe()
		{
			return "zone:" + Zone.ToString().ToLowerInvariant();
		}

		public static bool TryFor(string name, out ZoneCondition zone)
		{
			switch ((name ?? "").Trim().ToLowerInvariant())
			{
			case "overworld":
				zone = Overworld;
				return true;
			case "city":
			case "town":
				zone = City;
				return true;
			case "dungeon":
				zone = Dungeon;
				return true;
			default:
				zone = null;
				return false;
			}
		}
	}
	public sealed class AllOf : ICardCondition
	{
		public IReadOnlyList<ICardCondition> Parts { get; }

		public AllOf(IEnumerable<ICardCondition> parts)
		{
			Parts = Clean(parts);
		}

		public AllOf(params ICardCondition[] parts)
			: this((IEnumerable<ICardCondition>)parts)
		{
		}

		public bool IsMet(WorldSnapshot world)
		{
			for (int i = 0; i < Parts.Count; i++)
			{
				if (!Parts[i].IsMet(world))
				{
					return false;
				}
			}
			return true;
		}

		public string Describe()
		{
			return Join(Parts, " & ");
		}

		internal static List<ICardCondition> Clean(IEnumerable<ICardCondition> parts)
		{
			List<ICardCondition> list = new List<ICardCondition>();
			if (parts != null)
			{
				foreach (ICardCondition part in parts)
				{
					if (part != null)
					{
						list.Add(part);
					}
				}
			}
			return list;
		}

		internal static string Join(IReadOnlyList<ICardCondition> parts, string sep)
		{
			StringBuilder stringBuilder = new StringBuilder();
			for (int i = 0; i < parts.Count; i++)
			{
				if (i > 0)
				{
					stringBuilder.Append(sep);
				}
				string text = parts[i].Describe();
				stringBuilder.Append((parts[i] is AnyOf && parts.Count > 1) ? ("(" + text + ")") : text);
			}
			return stringBuilder.ToString();
		}
	}
	public sealed class AnyOf : ICardCondition
	{
		public IReadOnlyList<ICardCondition> Parts { get; }

		public AnyOf(IEnumerable<ICardCondition> parts)
		{
			Parts = AllOf.Clean(parts);
		}

		public AnyOf(params ICardCondition[] parts)
			: this((IEnumerable<ICardCondition>)parts)
		{
		}

		public bool IsMet(WorldSnapshot world)
		{
			if (Parts.Count == 0)
			{
				return true;
			}
			for (int i = 0; i < Parts.Count; i++)
			{
				if (Parts[i].IsMet(world))
				{
					return true;
				}
			}
			return false;
		}

		public string Describe()
		{
			return AllOf.Join(Parts, " | ");
		}
	}
	public sealed class Not : ICardCondition
	{
		public ICardCondition Inner { get; }

		public Not(ICardCondition inner)
		{
			Inner = inner ?? Always.Instance;
		}

		public bool IsMet(WorldSnapshot world)
		{
			return !Inner.IsMet(world);
		}

		public string Describe()
		{
			string text = Inner.Describe();
			if (!(Inner is AllOf) && !(Inner is AnyOf))
			{
				return "!" + text;
			}
			return "!(" + text + ")";
		}
	}
	public sealed class Always : ICardCondition
	{
		public static readonly Always Instance = new Always();

		private Always()
		{
		}

		public bool IsMet(WorldSnapshot world)
		{
			return true;
		}

		public string Describe()
		{
			return "always";
		}
	}
	public static class CardCondition
	{
		public static ICardCondition Parse(string text)
		{
			if (!TryParse(text, out ICardCondition condition, out string error))
			{
				throw new FormatException(error);
			}
			return condition;
		}

		public static bool TryParse(string text, out ICardCondition condition, out string error)
		{
			condition = Always.Instance;
			error = null;
			if (text == null || text.Trim().Length == 0)
			{
				return true;
			}
			List<ICardCondition> list = new List<ICardCondition>();
			string[] array = text.Split(new char[1] { '&' });
			foreach (string obj in array)
			{
				List<ICardCondition> list2 = new List<ICardCondition>();
				string[] array2 = obj.Split(new char[1] { '|' });
				for (int j = 0; j < array2.Length; j++)
				{
					string text2 = array2[j].Trim();
					if (text2.Length == 0)
					{
						error = "empty term in '" + text + "'";
						return false;
					}
					bool flag = text2[0] == '!';
					if (flag)
					{
						text2 = text2.Substring(1).Trim();
					}
					if (!TryLeaf(text2, out ICardCondition leaf, out error))
					{
						return false;
					}
					ICardCondition item;
					if (!flag)
					{
						item = leaf;
					}
					else
					{
						ICardCondition cardCondition = new Not(leaf);
						item = cardCondition;
					}
					list2.Add(item);
				}
				ICardCondition item2;
				if (list2.Count != 1)
				{
					ICardCondition cardCondition = new AnyOf(list2);
					item2 = cardCondition;
				}
				else
				{
					item2 = list2[0];
				}
				list.Add(item2);
			}
			ICardCondition cardCondition2;
			if (list.Count != 1)
			{
				ICardCondition cardCondition = new AllOf(list);
				cardCondition2 = cardCondition;
			}
			else
			{
				cardCondition2 = list[0];
			}
			condition = cardCondition2;
			return true;
		}

		private static bool TryLeaf(string atom, out ICardCondition leaf, out string error)
		{
			leaf = null;
			error = null;
			atom = atom.Trim();
			string text = atom.Replace(" ", "").Replace("\t", "");
			string text2 = text.ToLowerInvariant();
			switch (text2)
			{
			case "always":
				leaf = Always.Instance;
				return true;
			case "night":
				leaf = NightCondition.Night;
				return true;
			case "day":
				leaf = NightCondition.Day;
				return true;
			default:
				if (text2.StartsWith("hour=", StringComparison.Ordinal))
				{
					string[] array = text.Substring(5).Split(new char[1] { '-' });
					if (array.Length == 2 && TryNum(array[0], out var v) && TryNum(array[1], out var v2) && v >= 0f && v <= 24f && v2 >= 0f && v2 <= 24f)
					{
						leaf = new HourWindow(v, v2);
						return true;
					}
					error = "'" + atom + "': expected hour=<0-24>-<0-24>";
					return false;
				}
				if (text2.StartsWith("rain>", StringComparison.Ordinal) || text2.StartsWith("rain<", StringComparison.Ordinal))
				{
					if (TryNum(text.Substring(5), out var v3) && v3 >= 0f && v3 <= 1f)
					{
						leaf = new RainCondition(v3, text[4] == '>');
						return true;
					}
					error = "'" + atom + "': expected rain>X or rain<X with X in 0..1";
					return false;
				}
				if (text2.StartsWith("zone:", StringComparison.Ordinal))
				{
					if (ZoneCondition.TryFor(atom.Substring(5), out ZoneCondition zone))
					{
						leaf = zone;
						return true;
					}
					error = "'" + atom + "': expected zone:overworld, zone:city or zone:dungeon";
					return false;
				}
				if (text2.StartsWith("flag:", StringComparison.Ordinal))
				{
					return Named(atom.Substring(5), (string s) => new QuestFlagCondition(s, present: true), atom, out leaf, out error);
				}
				if (text2.StartsWith("faction:", StringComparison.Ordinal))
				{
					return Named(atom.Substring(8), (string s) => new FactionCondition(s), atom, out leaf, out error);
				}
				if (text2.StartsWith("region:", StringComparison.Ordinal))
				{
					return Named(atom.Substring(7), (string s) => new RegionCondition(s), atom, out leaf, out error);
				}
				if (text2.StartsWith("roomwarm:", StringComparison.Ordinal))
				{
					return Named(atom.Substring(9), (string s) => new RoomWarmCondition(s.Split(new char[1] { ',' })), atom, out leaf, out error);
				}
				error = "'" + atom + "': unknown condition (known: always, night, day, hour=A-B, rain>X, rain<X, zone:overworld|city|dungeon, flag:UID, faction:NAME, region:NAME, roomwarm:NAME[,NAME…])";
				return false;
			}
		}

		private static bool Named(string value, Func<string, ICardCondition> make, string atom, out ICardCondition leaf, out string error)
		{
			leaf = null;
			error = null;
			if (value.Trim().Length == 0)
			{
				error = "'" + atom + "': missing name";
				return false;
			}
			leaf = make(value.Trim());
			return true;
		}

		private static bool TryNum(string s, out float v)
		{
			if (float.TryParse(s.Trim(), NumberStyles.Float, CultureInfo.InvariantCulture, out v) && !float.IsNaN(v))
			{
				return !float.IsInfinity(v);
			}
			return false;
		}

		public static ICardCondition And(ICardCondition a, ICardCondition b)
		{
			bool flag = a == null || a is Always;
			bool flag2 = b == null || b is Always;
			if (flag && flag2)
			{
				return Always.Instance;
			}
			if (flag)
			{
				return b;
			}
			if (flag2)
			{
				return a;
			}
			return new AllOf(a, b);
		}
	}
	public readonly struct CarrotProbe
	{
		public const int DefaultStrikesToAct = 4;

		public const double DefaultDestEpsilonMeters = 5.0;

		public const double DefaultRemainingEpsilonMeters = 1.5;

		public const double DefaultTargetFarMeters = 15.0;

		public const double DefaultPartialEndEpsilonMeters = 5.0;

		public static readonly CarrotProbe Fresh = new CarrotProbe(0);

		public int Strikes { get; }

		public CarrotProbe(int strikes)
		{
			Strikes = strikes;
		}

		public static bool Suspicious(bool pathPending, bool pathComplete, double partialEndToBodyMeters, double destToCarrotMeters, double remainingMeters, double distToTargetMeters, double destEpsilonMeters = 5.0, double remainingEpsilonMeters = 1.5, double targetFarMeters = 15.0, double partialEndEpsilonMeters = 5.0)
		{
			if (pathPending)
			{
				return false;
			}
			if (distToTargetMeters <= targetFarMeters)
			{
				return false;
			}
			if (!pathComplete)
			{
				return partialEndToBodyMeters <= partialEndEpsilonMeters;
			}
			if (destToCarrotMeters > destEpsilonMeters)
			{
				return remainingMeters <= remainingEpsilonMeters;
			}
			return false;
		}

		public static CarrotProbe Advance(CarrotProbe p, bool suspicious, out bool act, int strikesToAct = 4)
		{
			if (strikesToAct < 1)
			{
				strikesToAct = 1;
			}
			if (!suspicious)
			{
				act = false;
				return Fresh;
			}
			int num = p.Strikes + 1;
			act = num >= strikesToAct;
			if (!act)
			{
				return new CarrotProbe(num);
			}
			return Fresh;
		}

		public override string ToString()
		{
			return $"strikes={Strikes}";
		}
	}
	public static class ClusterPlan
	{
		public static IReadOnlyList<(float x, float z)> Offsets(int count, float radius, double startAngle01)
		{
			if (count <= 0 || radius <= 0f)
			{
				return Array.Empty<(float, float)>();
			}
			if (startAngle01 < 0.0)
			{
				startAngle01 = 0.0;
			}
			if (startAngle01 > 1.0)
			{
				startAngle01 = 1.0;
			}
			List<(float, float)> list = new List<(float, float)>(count);
			double num = startAngle01 * 2.0 * Math.PI;
			double num2 = Math.PI * 2.0 / (double)count;
			for (int i = 0; i < count; i++)
			{
				double num3 = num + num2 * (double)i;
				list.Add(((float)(Math.Cos(num3) * (double)radius), (float)(Math.Sin(num3) * (double)radius)));
			}
			return list;
		}

		public static float MaxSpread(IReadOnlyList<(float x, float z)> positions)
		{
			if (positions == null || positions.Count < 2)
			{
				return 0f;
			}
			float num = 0f;
			for (int i = 0; i < positions.Count; i++)
			{
				for (int j = i + 1; j < positions.Count; j++)
				{
					float num2 = positions[i].x - positions[j].x;
					float num3 = positions[i].z - positions[j].z;
					float num4 = (float)Math.Sqrt(num2 * num2 + num3 * num3);
					if (num4 > num)
					{
						num = num4;
					}
				}
			}
			return num;
		}

		public static bool MaxSpreadOk(IReadOnlyList<(float x, float z)> positions, float clusterRadius, float tolerance = 6f)
		{
			if (clusterRadius <= 0f)
			{
				return false;
			}
			return MaxSpread(positions) <= clusterRadius * 2f + tolerance;
		}
	}
	public static class CombatDefer
	{
		public const double NotDeferring = double.NegativeInfinity;

		public static bool ShouldHold(bool enabled, bool inCombat, double deferSince, double now, float maxDeferSeconds)
		{
			if (!enabled || !inCombat)
			{
				return false;
			}
			if (maxDeferSeconds <= 0f)
			{
				return true;
			}
			if (double.IsNegativeInfinity(deferSince))
			{
				return true;
			}
			return now - deferSince < (double)maxDeferSeconds;
		}

		public static double Advance(bool inCombat, double deferSince, double now)
		{
			if (!inCombat)
			{
				return double.NegativeInfinity;
			}
			if (!double.IsNegativeInfinity(deferSince))
			{
				return deferSince;
			}
			return now;
		}
	}
	public enum DefendAction
	{
		None,
		Arm,
		Disarm,
		ClearLock
	}
	public readonly struct DefendGate
	{
		public static readonly DefendGate Fresh = new DefendGate(defending: false, -1.0);

		public bool Defending { get; }

		public double CalmSince { get; }

		public DefendGate(bool defending, double calmSince)
		{
			Defending = defending;
			CalmSince = calmSince;
		}

		public static DefendGate Advance(DefendGate g, bool hitThisTick, bool fighting, bool locked, double now, double calmSeconds, out DefendAction action)
		{
			action = DefendAction.None;
			fighting = hitThisTick || fighting;
			if (!g.Defending)
			{
				if (fighting)
				{
					action = DefendAction.Arm;
					return new DefendGate(defending: true, -1.0);
				}
				if (locked)
				{
					action = DefendAction.ClearLock;
				}
				return g;
			}
			if (fighting)
			{
				return new DefendGate(defending: true, -1.0);
			}
			double num = ((g.CalmSince < 0.0) ? now : g.CalmSince);
			if (calmSeconds <= 0.0 || now - num >= calmSeconds)
			{
				action = DefendAction.Disarm;
				return Fresh;
			}
			return new DefendGate(defending: true, num);
		}

		public override string ToString()
		{
			if (!Defending)
			{
				return "peaceful";
			}
			if (!(CalmSince < 0.0))
			{
				return $"defending, calm since {CalmSince:F1}";
			}
			return "defending";
		}
	}
	public sealed class EligibleDeck
	{
		public readonly struct Exclusion
		{
			public EventCard Card { get; }

			public string Reason { get; }

			public Exclusion(EventCard card, string reason)
			{
				Card = card;
				Reason = reason ?? "";
			}

			public override string ToString()
			{
				return Card?.Id + ": " + Reason;
			}
		}

		public IReadOnlyList<EventCard> Cards { get; }

		public IReadOnlyList<Exclusion> Excluded { get; }

		public WorldSnapshot World { get; }

		private EligibleDeck(List<EventCard> cards, List<Exclusion> excluded, WorldSnapshot world)
		{
			Cards = cards;
			Excluded = excluded;
			World = world;
		}

		public static EligibleDeck Build(IReadOnlyList<EventCard> source, WorldSnapshot world)
		{
			world = world ?? WorldSnapshot.Empty;
			List<EventCard> list = new List<EventCard>(source?.Count ?? 0);
			List<Exclusion> list2 = new List<Exclusion>();
			if (source != null)
			{
				for (int i = 0; i < source.Count; i++)
				{
					EventCard eventCard = source[i];
					if (eventCard == null)
					{
						continue;
					}
					ICardCondition condition = eventCard.Condition;
					if (condition == null || condition is Always)
					{
						list.Add(eventCard);
						continue;
					}
					bool flag;
					string reason;
					try
					{
						flag = condition.IsMet(world);
						reason = "needs " + condition.Describe();
					}
					catch (Exception ex)
					{
						flag = false;
						reason = "condition threw " + ex.GetType().Name + ": " + ex.Message;
					}
					if (flag)
					{
						list.Add(eventCard);
					}
					else
					{
						list2.Add(new Exclusion(eventCard, reason));
					}
				}
			}
			return new EligibleDeck(list, list2, world);
		}

		public bool IsExcluded(string id)
		{
			for (int i = 0; i < Excluded.Count; i++)
			{
				if (string.Equals(Excluded[i].Card.Id, id, StringComparison.OrdinalIgnoreCase))
				{
					return true;
				}
			}
			return false;
		}

		public string ReasonFor(string id)
		{
			for (int i = 0; i < Excluded.Count; i++)
			{
				if (string.Equals(Excluded[i].Card.Id, id, StringComparison.OrdinalIgnoreCase))
				{
					return Excluded[i].Reason;
				}
			}
			return "";
		}

		public string DescribeExclusions()
		{
			if (Excluded.Count == 0)
			{
				return "(every card eligible)";
			}
			StringBuilder stringBuilder = new StringBuilder();
			for (int i = 0; i < Excluded.Count; i++)
			{
				if (i > 0)
				{
					stringBuilder.Append("; ");
				}
				stringBuilder.Append(Excluded[i].ToString());
			}
			return stringBuilder.ToString();
		}
	}
	public sealed class EventCard
	{
		public string Id { get; }

		public double Weight { get; }

		public double CooldownSeconds { get; }

		public bool Enabled { get; }

		public ICardCondition Condition { get; }

		public bool Drawable
		{
			get
			{
				if (Enabled && Weight > 0.0)
				{
					return Id.Length > 0;
				}
				return false;
			}
		}

		public EventCard(string id, double weight, double cooldownSeconds, bool enabled)
			: this(id, weight, cooldownSeconds, enabled, null)
		{
		}

		public EventCard(string id, double weight, double cooldownSeconds, bool enabled, ICardCondition condition)
		{
			Id = (id ?? "").Trim();
			Weight = weight;
			CooldownSeconds = cooldownSeconds;
			Enabled = enabled;
			Condition = condition ?? Always.Instance;
		}

		public override string ToString()
		{
			return string.Format("{0} w={1:F2} cd={2:F0}s{3}", Id, Weight, CooldownSeconds, Enabled ? "" : " (disabled)") + ((Condition is Always) ? "" : (" when=" + Condition.Describe()));
		}
	}
	public readonly struct DeckState
	{
		private readonly Dictionary<string, double> _lastFiredAt;

		public static DeckState Empty => default(DeckState);

		private DeckState(Dictionary<string, double> lastFiredAt)
		{
			_lastFiredAt = lastFiredAt;
		}

		public double LastFiredAt(string id)
		{
			if (_lastFiredAt == null || string.IsNullOrEmpty(id))
			{
				return double.NegativeInfinity;
			}
			if (!_lastFiredAt.TryGetValue(id, out var value))
			{
				return double.NegativeInfinity;
			}
			return value;
		}

		public bool HasFired(string id)
		{
			return !double.IsNegativeInfinity(LastFiredAt(id));
		}

		internal DeckState With(string id, double now)
		{
			Dictionary<string, double> obj = ((_lastFiredAt == null) ? new Dictionary<string, double>(StringComparer.OrdinalIgnoreCase) : new Dictionary<string, double>(_lastFiredAt, StringComparer.OrdinalIgnoreCase));
			obj[id] = now;
			return new DeckState(obj);
		}
	}
	public static class EventDeck
	{
		public static string Draw(IReadOnlyList<EventCard> cards, DeckState state, double roll01, double now)
		{
			if (cards == null || cards.Count == 0)
			{
				return null;
			}
			EventCard eventCard = null;
			int num = 0;
			for (int i = 0; i < cards.Count; i++)
			{
				if (cards[i] != null && cards[i].Drawable)
				{
					num++;
					eventCard = cards[i];
				}
			}
			switch (num)
			{
			case 0:
				return null;
			case 1:
				if (!OnCooldown(eventCard, state, now))
				{
					return eventCard.Id;
				}
				return null;
			default:
			{
				double num2 = 0.0;
				for (int j = 0; j < cards.Count; j++)
				{
					if (Eligible(cards[j], state, now))
					{
						num2 += cards[j].Weight;
					}
				}
				if (num2 <= 0.0)
				{
					return null;
				}
				if (roll01 < 0.0)
				{
					roll01 = 0.0;
				}
				if (roll01 > 1.0)
				{
					roll01 = 1.0;
				}
				double num3 = roll01 * num2;
				string result = null;
				double num4 = 0.0;
				for (int k = 0; k < cards.Count; k++)
				{
					if (Eligible(cards[k], state, now))
					{
						num4 += cards[k].Weight;
						result = cards[k].Id;
						if (num3 < num4)
						{
							return cards[k].Id;
						}
					}
				}
				return result;
			}
			}
		}

		public static string Draw(IReadOnlyList<EventCard> cards, DeckState state, Func<double> roll01, double now)
		{
			if (cards == null || cards.Count == 0)
			{
				return null;
			}
			if (DrawableCount(cards) <= 1)
			{
				return Draw(cards, state, 0.0, now);
			}
			return Draw(cards, state, roll01?.Invoke() ?? 0.0, now);
		}

		public static DeckState MarkFired(DeckState state, string id, double now)
		{
			if (!string.IsNullOrEmpty(id))
			{
				return state.With(id.Trim(), now);
			}
			return state;
		}

		public static double CooldownRemaining(EventCard card, DeckState state, double now)
		{
			if (card == null || card.CooldownSeconds <= 0.0)
			{
				return 0.0;
			}
			double num = state.LastFiredAt(card.Id);
			if (double.IsNegativeInfinity(num))
			{
				return 0.0;
			}
			double num2 = num + card.CooldownSeconds - now;
			if (!(num2 > 0.0))
			{
				return 0.0;
			}
			return num2;
		}

		public static bool OnCooldown(EventCard card, DeckState state, double now)
		{
			return CooldownRemaining(card, state, now) > 0.0;
		}

		public static bool Eligible(EventCard card, DeckState state, double now)
		{
			if (card != null && card.Drawable)
			{
				return !OnCooldown(card, state, now);
			}
			return false;
		}

		public static int DrawableCount(IReadOnlyList<EventCard> cards)
		{
			int num = 0;
			if (cards == null)
			{
				return 0;
			}
			for (int i = 0; i < cards.Count; i++)
			{
				if (cards[i] != null && cards[i].Drawable)
				{
					num++;
				}
			}
			return num;
		}
	}
	public static class EventGuard
	{
		public static IEnumerator Wrap(Func<IEnumerator> factory, Func<bool> completed, Action<Exception> onThrow, Action onFellOff)
		{
			if (factory == null)
			{
				onFellOff?.Invoke();
				yield break;
			}
			IEnumerator inner;
			try
			{
				inner = factory();
			}
			catch (Exception obj)
			{
				onThrow?.Invoke(obj);
				yield break;
			}
			IEnumerator wrapped = Wrap(inner, completed, onThrow, onFellOff);
			while (wrapped.MoveNext())
			{
				yield return wrapped.Current;
			}
		}

		public static IEnumerator Wrap(IEnumerator inner, Func<bool> completed, Action<Exception> onThrow, Action onFellOff)
		{
			if (inner == null)
			{
				onFellOff?.Invoke();
				yield break;
			}
			while (true)
			{
				object current;
				try
				{
					if (!inner.MoveNext())
					{
						break;
					}
					current = inner.Current;
					goto IL_0067;
				}
				catch (Exception obj)
				{
					onThrow?.Invoke(obj);
					yield break;
				}
				IL_0067:
				yield return current;
			}
			if (completed == null || !completed())
			{
				onFellOff?.Invoke();
			}
		}
	}
	public sealed class FactionTable
	{
		private readonly Dictionary<string, string> _byName = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

		public int Count => _byName.Count;

		public static FactionTable Parse(string text)
		{
			FactionTable factionTable = new FactionTable();
			if (string.IsNullOrEmpty(text))
			{
				return factionTable;
			}
			string[] array = text.Split(new char[1] { '\n' });
			for (int i = 0; i < array.Length; i++)
			{
				string text2 = array[i].Trim();
				if (text2.Length == 0 || text2[0] == '#')
				{
					continue;
				}
				int num = text2.IndexOf('=');
				if (num > 0 && num != text2.Length - 1)
				{
					string text3 = text2.Substring(0, num).Trim();
					string text4 = text2.Substring(num + 1).Trim();
					if (text3.Length != 0 && text4.Length != 0)
					{
						factionTable._byName[text3] = text4;
					}
				}
			}
			return factionTable;
		}

		public string FactionOf(string species)
		{
			string text = (species ?? "").Trim();
			if (text.Length == 0)
			{
				return null;
			}
			if (_byName.TryGetValue(text, out string value))
			{
				return value;
			}
			string result = null;
			int num = 0;
			foreach (KeyValuePair<string, string> item in _byName)
			{
				if (item.Key.Length > num && text.IndexOf(item.Key, StringComparison.OrdinalIgnoreCase) >= 0)
				{
					result = item.Value;
					num = item.Key.Length;
				}
			}
			return result;
		}

		public bool IsKnown(string species)
		{
			return FactionOf(species) != null;
		}

		public bool Observe(string species, string faction, out string previous)
		{
			previous = null;
			string text = (species ?? "").Trim();
			string text2 = (faction ?? "").Trim();
			if (text.Length == 0 || text2.Length == 0)
			{
				return false;
			}
			string text3 = (previous = FactionOf(text));
			_byName[text] = text2;
			if (text3 != null)
			{
				return !string.Equals(text3, text2, StringComparison.OrdinalIgnoreCase);
			}
			return true;
		}

		public List<string> SameFaction(string species, IEnumerable<string> pool)
		{
			List<string> list = new List<string>();
			string text = FactionOf(species);
			if (text == null || pool == null)
			{
				return list;
			}
			foreach (string item in pool)
			{
				if (string.Equals(FactionOf(item), text, StringComparison.OrdinalIgnoreCase))
				{
					list.Add(item);
				}
			}
			return list;
		}

		public List<string> ToLines()
		{
			List<string> list = new List<string>(_byName.Keys);
			list.Sort(StringComparer.OrdinalIgnoreCase);
			List<string> list2 = new List<string>(list.Count);
			foreach (string item in list)
			{
				list2.Add(item + "=" + _byName[item]);
			}
			return list2;
		}
	}
	public sealed class FarEntry
	{
		public string SpeciesKey = "";

		public float X;

		public float Y;

		public float Z;

		public float RotY;

		public float HpFrac;

		public double StoredAt;

		public bool InFlight;

		public bool WarmHeldLogged;
	}
	public sealed class FarCache
	{
		private readonly List<FarEntry> _entries = new List<FarEntry>();

		private readonly int _maxEntries;

		public int Count => _entries.Count;

		public IReadOnlyList<FarEntry> Entries => _entries;

		public FarCache(int maxEntries)
		{
			_maxEntries = Math.Max(1, maxEntries);
		}

		public static float ClampRestoreRadius(float despawnRadius, float restoreRadius)
		{
			return Math.Min(restoreRadius, despawnRadius * 0.8f);
		}

		public static bool FarFromAll(float x, float y, float z, IReadOnlyList<(float x, float y, float z)> players, float radius)
		{
			if (players == null || players.Count == 0)
			{
				return false;
			}
			float num = radius * radius;
			for (int i = 0; i < players.Count; i++)
			{
				float num2 = players[i].x - x;
				float num3 = players[i].y - y;
				float num4 = players[i].z - z;
				if (num2 * num2 + num3 * num3 + num4 * num4 <= num)
				{
					return false;
				}
			}
			return true;
		}

		private static bool NearAny(FarEntry e, IReadOnlyList<(float x, float y, float z)> players, float radius)
		{
			if (players == null)
			{
				return false;
			}
			float num = radius * radius;
			for (int i = 0; i < players.Count; i++)
			{
				float num2 = players[i].x - e.X;
				float num3 = players[i].y - e.Y;
				float num4 = players[i].z - e.Z;
				if (num2 * num2 + num3 * num3 + num4 * num4 <= num)
				{
					return true;
				}
			}
			return false;
		}

		public void Add(FarEntry entry, double now, double maxAgeSeconds)
		{
			DropExpired(now, maxAgeSeconds);
			entry.HpFrac = Math.Min(1f, Math.Max(0.01f, entry.HpFrac));
			entry.StoredAt = now;
			while (_entries.Count >= _maxEntries)
			{
				int num = OldestEvictableIndex();
				if (num < 0)
				{
					break;
				}
				_entries.RemoveAt(num);
			}
			_entries.Add(entry);
		}

		public void CollectRestorable(IReadOnlyList<(float x, float y, float z)> players, float restoreRadius, double now, double maxAgeSeconds, List<FarEntry> into)
		{
			into.Clear();
			DropExpired(now, maxAgeSeconds);
			foreach (FarEntry entry in _entries)
			{
				if (!entry.InFlight && NearAny(entry, players, restoreRadius))
				{
					into.Add(entry);
				}
			}
			into.Sort((FarEntry a, FarEntry b) => a.StoredAt.CompareTo(b.StoredAt));
		}

		public bool Remove(FarEntry entry)
		{
			return _entries.Remove(entry);
		}

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

		private int OldestEvictableIndex()
		{
			int num = -1;
			for (int i = 0; i < _entries.Count; i++)
			{
				if (!_entries[i].InFlight && (num < 0 || _entries[i].StoredAt < _entries[num].StoredAt))
				{
					num = i;
				}
			}
			return num;
		}

		private void DropExpired(double now, double maxAgeSeconds)
		{
			if (maxAgeSeconds <= 0.0)
			{
				return;
			}
			for (int num = _entries.Count - 1; num >= 0; num--)
			{
				if (!_entries[num].InFlight && now - _entries[num].StoredAt > maxAgeSeconds)
				{
					_entries.RemoveAt(num);
				}
			}
		}
	}
	public enum FriendlyBlipVerdict
	{
		Blip,
		Disabled,
		NotAlive,
		MerchantOwned
	}
	public static class FriendlyBlip
	{
		public static FriendlyBlipVerdict Classify(bool showFriendly, bool isAlive, string ownerTag, string merchantOwnerTag)
		{
			if (!showFriendly)
			{
				return FriendlyBlipVerdict.Disabled;
			}
			if (!isAlive)
			{
				return FriendlyBlipVerdict.NotAlive;
			}
			if (!string.IsNullOrEmpty(merchantOwnerTag) && string.Equals(ownerTag, merchantOwnerTag, StringComparison.Ordinal))
			{
				return FriendlyBlipVerdict.MerchantOwned;
			}
			return FriendlyBlipVerdict.Blip;
		}
	}
	public enum GreetEdge
	{
		None,
		Paused,
		Resumed
	}
	public readonly struct GreetPause
	{
		public static readonly GreetPause Fresh = new GreetPause(paused: false, -1.0);

		public bool Paused { get; }

		public double AwayAt { get; }

		public GreetPause(bool paused, double awayAt)
		{
			Paused = paused;
			AwayAt = awayAt;
		}

		public static GreetPause Advance(GreetPause p, bool hold, double now, double resumeSeconds, out GreetEdge edge)
		{
			edge = GreetEdge.None;
			if (!p.Paused)
			{
				if (!hold)
				{
					return p;
				}
				edge = GreetEdge.Paused;
				return new GreetPause(paused: true, -1.0);
			}
			if (hold)
			{
				return new GreetPause(paused: true, -1.0);
			}
			double num = ((p.AwayAt < 0.0) ? now : p.AwayAt);
			if (resumeSeconds <= 0.0 || now - num >= resumeSeconds)
			{
				edge = GreetEdge.Resumed;
				return Fresh;
			}
			return new GreetPause(paused: true, num);
		}

		public override string ToString()
		{
			if (!Paused)
			{
				return "walking";
			}
			if (!(AwayAt < 0.0))
			{
				return $"paused, away since {AwayAt:F1}";
			}
			return "paused";
		}
	}
	public enum DefendVerdict
	{
		Defend,
		Disabled,
		WrongPhase,
		NotAlive,
		NotAI,
		PlayerSide,
		PatrolMember,
		PeacefulFaction,
		PlotOrNamed,
		NotEngaged,
		TooFarFromPlayer,
		BeyondLeash
	}
	public readonly struct DefendCandidate
	{
		public string Name { get; }

		public string Faction { get; }

		public bool IsAI { get; }

		public bool Alive { get; }

		public bool PatrolMember { get; }

		public bool EngagedWithPlayerSide { get; }

		public double DistanceToPlayer { get; }

		public double DistanceToParty { get; }

		public DefendCandidate(string? name, string? faction, bool isAI, bool alive, bool patrolMember, bool engagedWithPlayerSide, double distanceToPlayer, double distanceToParty)
		{
			Name = name ?? "";
			Faction = faction ?? "";
			IsAI = isAI;
			Alive = alive;
			PatrolMember = patrolMember;
			EngagedWithPlayerSide = engagedWithPlayerSide;
			DistanceToPlayer = distanceToPlayer;
			DistanceToParty = distanceToParty;
		}
	}
	public readonly struct DefendRules
	{
		public bool Enabled { get; }

		public double RadiusMeters { get; }

		public double LeashMeters { get; }

		public DefendRules(bool enabled, double radiusMeters, double leashMeters)
		{
			Enabled = enabled;
			RadiusMeters = radiusMeters;
			LeashMeters = leashMeters;
		}
	}
	public static class GuardDefend
	{
		public static readonly string[] HostileFactions = new string[5] { "Bandits", "Mercs", "Tuanosaurs", "Hounds", "CorruptionSpirit" };

		public static bool IsHostileFaction(string? faction)
		{
			if (string.IsNullOrWhiteSpace(faction))
			{
				return false;
			}
			string a = faction.Trim();
			for (int i = 0; i < HostileFactions.Length; i++)
			{
				if (string.Equals(a, HostileFactions[i], StringComparison.OrdinalIgnoreCase))
				{
					return true;
				}
			}
			return false;
		}

		public static bool PhaseAllows(PatrolPhase phase)
		{
			if (phase != PatrolPhase.Spawning && phase != PatrolPhase.Fighting)
			{
				return phase == PatrolPhase.Resolved;
			}
			return true;
		}

		public static DefendVerdict Judge(PatrolPhase phase, in DefendCandidate c, in DefendRules rules, IEnumerable<string>? extraBlocklist = null)
		{
			if (!rules.Enabled)
			{
				return DefendVerdict.Disabled;
			}
			if (!PhaseAllows(phase))
			{
				return DefendVerdict.WrongPhase;
			}
			if (!c.Alive)
			{
				return DefendVerdict.NotAlive;
			}
			if (!c.IsAI)
			{
				return DefendVerdict.NotAI;
			}
			if (string.Equals(c.Faction, "Player", StringComparison.OrdinalIgnoreCase))
			{
				return DefendVerdict.PlayerSide;
			}
			if (c.PatrolMember)
			{
				return DefendVerdict.PatrolMember;
			}
			if (!IsHostileFaction(c.Faction))
			{
				return DefendVerdict.PeacefulFaction;
			}
			if (RosterFilter.IsBlocked(c.Name, extraBlocklist))
			{
				return DefendVerdict.PlotOrNamed;
			}
			if (!c.EngagedWithPlayerSide)
			{
				return DefendVerdict.NotEngaged;
			}
			if (c.DistanceToPlayer > rules.RadiusMeters)
			{
				return DefendVerdict.TooFarFromPlayer;
			}
			if (!LeashHolds(c.DistanceToParty, rules.LeashMeters))
			{
				return DefendVerdict.BeyondLeash;
			}
			return DefendVerdict.Defend;
		}

		public static bool LeashHolds(double distanceToParty, double leashMeters)
		{
			if (!(leashMeters <= 0.0))
			{
				return distanceToParty <= leashMeters;
			}
			return true;
		}

		public static string Explain(DefendVerdict v)
		{
			return v switch
			{
				DefendVerdict.Defend => "defend", 
				DefendVerdict.Disabled => "DefendPlayer=false", 
				DefendVerdict.WrongPhase => "the patrol is leaving", 
				DefendVerdict.NotAlive => "not alive", 
				DefendVerdict.NotAI => "not an AI", 
				DefendVerdict.PlayerSide => "Player faction (a player, a summon or a pet)", 
				DefendVerdict.PatrolMember => "one of the patrol's own", 
				DefendVerdict.PeacefulFaction => "a faction the guards have no quarrel with", 
				DefendVerdict.PlotOrNamed => "blocklisted (unique/boss/plot faction)", 
				DefendVerdict.NotEngaged => "not fighting the player side", 
				DefendVerdict.TooFarFromPlayer => "too far from every player", 
				DefendVerdict.BeyondLeash => "beyond the patrol's leash", 
				_ => v.ToString(), 
			};
		}
	}
	public enum GuardTown
	{
		Cierzo,
		Berg,
		Levant,
		Monsoon,
		Harmattan,
		NewSirocco
	}
	public static class GuardLook
	{
		public static GuardTown? ForAreaId(int areaId)
		{
			return areaId switch
			{
				101 => GuardTown.Cierzo, 
				201 => GuardTown.Monsoon, 
				301 => GuardTown.Levant, 
				401 => GuardTown.Harmattan, 
				501 => GuardTown.Berg, 
				602 => GuardTown.NewSirocco, 
				_ => null, 
			};
		}

		public static GuardTown? ForName(string name)
		{
			if (string.IsNullOrEmpty(name))
			{
				return null;
			}
			string haystack = name.Trim();
			if (Match(haystack, "cierzo", "chersonese"))
			{
				return GuardTown.Cierzo;
			}
			if (Match(haystack, "berg", "enmerkar", "forest"))
			{
				return GuardTown.Berg;
			}
			if (Match(haystack, "levant", "abrassar"))
			{
				return GuardTown.Levant;
			}
			if (Match(haystack, "monsoon", "hallowed", "marsh"))
			{
				return GuardTown.Monsoon;
			}
			if (Match(haystack, "harmattan", "antique", "plateau"))
			{
				return GuardTown.Harmattan;
			}
			if (Match(haystack, "sirocco", "caldera"))
			{
				return GuardTown.NewSirocco;
			}
			return null;
		}

		private static bool Match(string haystack, params string[] needles)
		{
			for (int i = 0; i < needles.Length; i++)
			{
				if (haystack.IndexOf(needles[i], StringComparison.OrdinalIgnoreCase) >= 0)
				{
					return true;
				}
			}
			return false;
		}

		public static string Name(GuardTown town)
		{
			if (town != GuardTown.NewSirocco)
			{
				return town.ToString();
			}
			return "New Sirocco";
		}
	}
	public enum HazardShapeKind
	{
		Bounds,
		HeightBelow,
		HeightAbove,
		Sphere
	}
	public struct HazardShape
	{
		public HazardShapeKind Kind;

		public float CenterX;

		public float CenterY;

		public float CenterZ;

		public float ExtentX;

		public float ExtentY;

		public float ExtentZ;

		public bool Contains(float x, float y, float z)
		{
			switch (Kind)
			{
			case HazardShapeKind.Bounds:
				if (x >= CenterX - ExtentX && x <= CenterX + ExtentX && y >= CenterY - ExtentY && y <= CenterY + ExtentY && z >= CenterZ - ExtentZ)
				{
					return z <= CenterZ + ExtentZ;
				}
				return false;
			case HazardShapeKind.HeightBelow:
				return y <= CenterY;
			case HazardShapeKind.HeightAbove:
				return y >= CenterY;
			case HazardShapeKind.Sphere:
			{
				float num = x - CenterX;
				float num2 = y - CenterY;
				float num3 = z - CenterZ;
				return num * num + num2 * num2 + num3 * num3 <= ExtentX * ExtentX;
			}
			default:
				return false;
			}
		}
	}
	public sealed class HazardTester
	{
		public bool AllRequired;

		public readonly List<HazardShape> Shapes = new List<HazardShape>();

		public bool Covers(float x, float y, float z)
		{
			if (Shapes.Count == 0)
			{
				return false;
			}
			if (AllRequired)
			{
				foreach (HazardShape shape in Shapes)
				{
					if (!shape.Contains(x, y, z))
					{
						return false;
					}
				}
				return true;
			}
			foreach (HazardShape shape2 in Shapes)
			{
				if (shape2.Contains(x, y, z))
				{
					return true;
				}
			}
			return false;
		}
	}
	public static class HazardField
	{
		public static bool IsHazardous(IReadOnlyList<HazardTester> testers, float x, float y, float z)
		{
			if (testers == null)
			{
				return false;
			}
			foreach (HazardTester tester in testers)
			{
				if (tester.Covers(x, y, z))
				{
					return true;
				}
			}
			return false;
		}
	}
	public enum LeaveAction
	{
		Skip,
		RemoveGone,
		RemoveCorpse,
		RemoveFar,
		HoldCorpse,
		Hold
	}
	public static class LeaveRule
	{
		public static LeaveAction Decide(bool removed, bool bodyGone, bool alive, bool farFromEveryPlayer)
		{
			if (removed)
			{
				return LeaveAction.Skip;
			}
			if (bodyGone)
			{
				return LeaveAction.RemoveGone;
			}
			if (!alive)
			{
				if (!farFromEveryPlayer)
				{
					return LeaveAction.HoldCorpse;
				}
				return LeaveAction.RemoveCorpse;
			}
			if (!farFromEveryPlayer)
			{
				return LeaveAction.Hold;
			}
			return LeaveAction.RemoveFar;
		}

		public static bool StillHere(LeaveAction action)
		{
			return action == LeaveAction.Hold;
		}
	}
	public enum LoadPriorityChoice
	{
		Unchanged,
		Low,
		BelowNormal,
		Normal,
		High
	}
	public static class LoadPriority
	{
		public static LoadPriorityChoice Parse(string raw)
		{
			string text = (raw ?? "").Trim();
			if (text.Length == 0)
			{
				return LoadPriorityChoice.Unchanged;
			}
			if (Eq(text, "unchanged") || Eq(text, "default") || Eq(text, "off") || Eq(text, "none"))
			{
				return LoadPriorityChoice.Unchanged;
			}
			if (Eq(text, "low"))
			{
				return LoadPriorityChoice.Low;
			}
			if (Eq(text, "belownormal") || Eq(text, "below normal"))
			{
				return LoadPriorityChoice.BelowNormal;
			}
			if (Eq(text, "normal"))
			{
				return LoadPriorityChoice.Normal;
			}
			if (Eq(text, "high"))
			{
				return LoadPriorityChoice.High;
			}
			return LoadPriorityChoice.Unchanged;
		}

		public static bool Applies(LoadPriorityChoice choice)
		{
			return choice != LoadPriorityChoice.Unchanged;
		}

		private static bool Eq(string a, string b)
		{
			return string.Equals(a, b, StringComparison.OrdinalIgnoreCase);
		}
	}
	public sealed class MeasureLedger
	{
		private sealed class SourceStats
		{
			internal int Offered;

			internal int Accepted;

			internal int WavesUsed;

			internal double DistanceSum;

			internal int DistanceCount;

			internal double RatioSum;

			internal int RatioCount;

			internal readonly Dictionary<RejectReason, int> Rejects = new Dictionary<RejectReason, int>();
		}

		private readonly List<string> _sources = new List<string>();

		private readonly Dictionary<string, Dictionary<string, SourceStats>> _areas = new Dictionary<string, Dictionary<string, SourceStats>>(StringComparer.OrdinalIgnoreCase);

		public IReadOnlyList<string> Sources => _sources;

		public IReadOnlyList<string> Areas
		{
			get
			{
				List<string> list = new List<string>(_areas.Keys);
				list.Sort(StringComparer.OrdinalIgnoreCase);
				return list;
			}
		}

		public void RegisterSource(string sourceId)
		{
			string text = (sourceId ?? "").Trim();
			if (text.Length == 0)
			{
				return;
			}
			for (int i = 0; i < _sources.Count; i++)
			{
				if (string.Equals(_sources[i], text, StringComparison.OrdinalIgnoreCase))
				{
					return;
				}
			}
			_sources.Add(text);
		}

		public void Candidate(string areaKey, string sourceId, RejectReason reason, float distance, float ratio)
		{
			SourceStats sourceStats = Stats(areaKey, sourceId);
			sourceStats.Offered++;
			if (reason == RejectReason.None)
			{
				sourceStats.Accepted++;
			}
			else
			{
				sourceStats.Rejects[reason] = ((!sourceStats.Rejects.TryGetValue(reason, out var value)) ? 1 : (value + 1));
			}
			if (distance >= 0f)
			{
				sourceStats.DistanceSum += distance;
				sourceStats.DistanceCount++;
			}
			if (ratio >= 0f)
			{
				sourceStats.RatioSum += ratio;
				sourceStats.RatioCount++;
			}
		}

		public void WaveUsed(string areaKey, string sourceId)
		{
			Stats(areaKey, sourceId).WavesUsed++;
		}

		public void SourceEmpty(string areaKey, string sourceId)
		{
			SourceStats sourceStats = Stats(areaKey, sourceId);
			sourceStats.Rejects[RejectReason.SourceEmpty] = ((!sourceStats.Rejects.TryGetValue(RejectReason.SourceEmpty, out var value)) ? 1 : (value + 1));
		}

		public void Reset()
		{
			_areas.Clear();
		}

		public string Format(string areaKey)
		{
			string text = (areaKey ?? "").Trim();
			if (text.Length == 0)
			{
				text = "(unknown)";
			}
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.Append("area ").Append(text).Append(" — anchor sources")
				.AppendLine();
			if (!_areas.TryGetValue(text, out Dictionary<string, SourceStats> value))
			{
				stringBuilder.Append("  (no candidates recorded here yet)");
				return stringBuilder.ToString();
			}
			stringBuilder.Append("  ").Append("source".PadRight(16)).Append("offered".PadLeft(8))
				.Append("accept".PadLeft(8))
				.Append("used".PadLeft(6))
				.Append("avgDist".PadLeft(9))
				.Append("avgRatio".PadLeft(10))
				.Append("  rejects")
				.AppendLine();
			for (int i = 0; i < _sources.Count; i++)
			{
				string text2 = _sources[i];
				value.TryGetValue(text2, out var value2);
				if (value2 == null)
				{
					value2 = new SourceStats();
				}
				stringBuilder.Append("  ").Append(text2.PadRight(16)).Append(value2.Offered.ToString(CultureInfo.InvariantCulture).PadLeft(8))
					.Append(value2.Accepted.ToString(CultureInfo.InvariantCulture).PadLeft(8))
					.Append(value2.WavesUsed.ToString(CultureInfo.InvariantCulture).PadLeft(6))
					.Append(Avg(value2.DistanceSum, value2.DistanceCount).PadLeft(9))
					.Append(Avg(value2.RatioSum, value2.RatioCount).PadLeft(10))
					.Append("  ")
					.Append(FormatRejects(value2.Rejects))
					.AppendLine();
			}
			return stringBuilder.ToString().TrimEnd(Array.Empty<char>());
		}

		public string FormatAll()
		{
			IReadOnlyList<string> areas = Areas;
			if (areas.Count == 0)
			{
				return "no candidates recorded in any area yet";
			}
			StringBuilder stringBuilder = new StringBuilder();
			for (int i = 0; i < areas.Count; i++)
			{
				if (i > 0)
				{
					stringBuilder.AppendLine();
				}
				stringBuilder.AppendLine(Format(areas[i]));
			}
			return stringBuilder.ToString().TrimEnd(Array.Empty<char>());
		}

		private static string Avg(double sum, int count)
		{
			if (count != 0)
			{
				return (sum / (double)count).ToString("F1", CultureInfo.InvariantCulture);
			}
			return "-";
		}

		private static string FormatRejects(Dictionary<RejectReason, int> rejects)
		{
			if (rejects.Count == 0)
			{
				return "-";
			}
			List<KeyValuePair<RejectReason, int>> list = new List<KeyValuePair<RejectReason, int>>(rejects);
			list.Sort(delegate(KeyValuePair<RejectReason, int> a, KeyValuePair<RejectReason, int> b)
			{
				int num2 = b.Value.CompareTo(a.Value);
				return (num2 == 0) ? string.CompareOrdinal(a.Key.ToString(), b.Key.ToString()) : num2;
			});
			StringBuilder stringBuilder = new StringBuilder();
			for (int num = 0; num < list.Count; num++)
			{
				if (num > 0)
				{
					stringBuilder.Append(' ');
				}
				stringBuilder.Append(list[num].Key).Append('=').Append(list[num].Value.ToString(CultureInfo.InvariantCulture));
			}
			return stringBuilder.ToString();
		}

		private SourceStats Stats(string areaKey, string sourceId)
		{
			string key = (string.IsNullOrWhiteSpace(areaKey) ? "(unknown)" : areaKey.Trim());
			string text = (string.IsNullOrWhiteSpace(sourceId) ? "(unknown)" : sourceId.Trim());
			RegisterSource(text);
			if (!_areas.TryGetValue(key, out Dictionary<string, SourceStats> value))
			{
				value = new Dictionary<string, SourceStats>(StringComparer.OrdinalIgnoreCase);
				_areas[key] = value;
			}
			if (!value.TryGetValue(text, out var value2))
			{
				value2 = (value[text] = new SourceStats());
			}
			return value2;
		}
	}
	public static class MerchantText
	{
		public const string UnknownDestination = "the next town";

		public const string RaidToast = "Bandits are closing on the merchant!";

		public static string Greeting(string destinationName)
		{
			return "Traveller. Keep your hands where I can see them and we'll get on fine. I'm bound for " + Dest(destinationName) + " — if you're buying, I'm selling.";
		}

		public static string GreetingRescued(string destinationName)
		{
			return "You again. I'd be feeding the crows if you hadn't stepped in back there. Whatever you need before " + Dest(destinationName) + ", the pack's open — and the prices are kinder.";
		}

		public static string RoadFlavour(string destinationName, string bearing)
		{
			string s = Dest(destinationName);
			string text = Clean(bearing);
			if (text.Length <= 0)
			{
				return Cap(s) + " is the other end of this road, and the road between is no friend to anyone. Bandits take the pack if the beasts don't take the mule. I walk it anyway — nobody pays for goods that stay in the warehouse.";
			}
			return Cap(s) + " lies " + text + " of here, and the road between is no friend to anyone. Bandits take the pack if the beasts don't take the mule. I walk it anyway — nobody pays for goods that stay in the warehouse.";
		}

		public static string Toast(string bearing)
		{
			string text = Clean(bearing);
			if (text.Length <= 0)
			{
				return "A merchant is on the road nearby.";
			}
			return "A merchant is on the road to the " + text + ".";
		}

		private static string Dest(string destinationName)
		{
			string text = Clean(destinationName);
			if (text.Length <= 0)
			{
				return "the next town";
			}
			return text;
		}

		private static string Clean(string s)
		{
			return (s ?? "").Trim();
		}

		private static string Cap(string s)
		{
			if (s.Length != 0)
			{
				return char.ToUpperInvariant(s[0]) + s.Substring(1);
			}
			return s;
		}
	}
	public static class ParkRule
	{
		public static bool ReadsAsFighting(bool characterInCombat, bool aiIsFighting, bool hasLockedTarget)
		{
			return ReadsAsFighting(characterInCombat, aiIsFighting, hasLockedTarget, aiFrozen: false);
		}

		public static bool ReadsAsFighting(bool characterInCombat, bool aiIsFighting, bool hasLockedTarget, bool aiFrozen)
		{
			if (!aiFrozen)
			{
				return characterInCombat || aiIsFighting || hasLockedTarget;
			}
			return false;
		}

		public static bool ShouldPark(bool alive, bool fighting, bool farFromEveryPlayer)
		{
			return ShouldPark(alive, fighting, farFromEveryPlayer, beyondMidFightRadius: false);
		}

		public static bool ShouldPark(bool alive, bool fighting, bool farFromEveryPlayer, bool beyondMidFightRadius)
		{
			return ShouldPark(alive, fighting, farFromEveryPlayer, beyondMidFightRadius, eventOwned: false);
		}

		public static bool ShouldPark(bool alive, bool fighting, bool farFromEveryPlayer, bool beyondMidFightRadius, bool eventOwned)
		{
			if (!alive || eventOwned || !farFromEveryPlayer)
			{
				return false;
			}
			return !fighting || beyondMidFightRadius;
		}

		public static float EffectiveMidFightRadius(float despawnRadius, float parkMidFightBeyond)
		{
			if (parkMidFightBeyond <= 0f)
			{
				return 0f;
			}
			if (!(parkMidFightBeyond < despawnRadius))
			{
				return parkMidFightBeyond;
			}
			return despawnRadius;
		}
	}
	public sealed class PatrolLedger
	{
		private readonly List<string> _spawned = new List<string>();

		private readonly HashSet<string> _spawnedSet = new HashSet<string>(StringComparer.Ordinal);

		private readonly HashSet<string> _dead = new HashSet<string>(StringComparer.Ordinal);

		private readonly HashSet<string> _helpedOn = new HashSet<string>(StringComparer.Ordinal);

		public int Spawned => _spawned.Count;

		public int DeadCount => _dead.Count;

		public bool Helped => _helpedOn.Count > 0;

		public int HelpedOn => _helpedOn.Count;

		public bool Paid { get; private set; }

		public IReadOnlyList<string> Uids => _spawned;

		public bool Note(string uid)
		{
			if (string.IsNullOrEmpty(uid) || _spawnedSet.Contains(uid))
			{
				return false;
			}
			_spawnedSet.Add(uid);
			_spawned.Add(uid);
			return true;
		}

		public bool NoteDead(string uid)
		{
			if (string.IsNullOrEmpty(uid) || !_spawnedSet.Contains(uid))
			{
				return false;
			}
			return _dead.Add(uid);
		}

		public bool NoteHelped(string uid)
		{
			if (string.IsNullOrEmpty(uid) || !_spawnedSet.Contains(uid))
			{
				return false;
			}
			return _helpedOn.Add(uid);
		}

		public bool IsOurs(string uid)
		{
			if (!string.IsNullOrEmpty(uid))
			{
				return _spawnedSet.Contains(uid);
			}
			return false;
		}

		public bool MarkPaid()
		{
			if (Paid)
			{
				return false;
			}
			Paid = true;
			return true;
		}

		public override string ToString()
		{
			return $"spawned={Spawned} dead={DeadCount} helped={Helped}(on {HelpedOn}) paid={Paid}";
		}
	}
	public static class PatrolPlan
	{
		public static readonly string[] TrogSpecies = new string[7] { "Troglodyte", "Armored Troglodyte", "Mana Troglodyte", "Troglodyte Grenadier", "Troglodyte Knight", "Troglodyte Archmage", "That Annoying Troglodyte" };

		public static readonly string[] QueenGameObjectNames = new string[2] { "EliteTroglodyteQueen", "TroglodyteQueen" };

		public static bool IsQueenBody(string goName)
		{
			if (string.IsNullOrEmpty(goName))
			{
				return false;
			}
			for (int i = 0; i < QueenGameObjectNames.Length; i++)
			{
				if (goName.IndexOf(QueenGameObjectNames[i], StringComparison.OrdinalIgnoreCase) >= 0)
				{
					return true;
				}
			}
			if (goName.IndexOf("queen", StringComparison.OrdinalIgnoreCase) >= 0)
			{
				return goName.IndexOf("trog", StringComparison.OrdinalIgnoreCase) >= 0;
			}
			return false;
		}

		public static string PickSpecies(IReadOnlyList<string> allowed, double roll01)
		{
			if (allowed == null || allowed.Count == 0)
			{
				return null;
			}
			if (roll01 < 0.0)
			{
				roll01 = 0.0;
			}
			if (roll01 >= 1.0)
			{
				roll01 = 0.999999;
			}
			return allowed[(int)Math.Floor(roll01 * (double)allowed.Count)];
		}

		public static string SpeciesSummary(IReadOnlyList<string> perTrogSpecies)
		{
			if (perTrogSpecies == null || perTrogSpecies.Count == 0)
			{
				return "";
			}
			HashSet<string> hashSet = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
			foreach (string perTrogSpecy in perTrogSpecies)
			{
				if (!string.IsNullOrEmpty(perTrogSpecy))
				{
					hashSet.Add(perTrogSpecy);
				}
			}
			List<string> list = new List<string>();
			string[] trogSpecies = TrogSpecies;
			foreach (string item in trogSpecies)
			{
				if (hashSet.Contains(item))
				{
					list.Add(item);
				}
			}
			foreach (string perTrogSpecy2 in perTrogSpecies)
			{
				if (string.IsNullOrEmpty(perTrogSpecy2))
				{
					continue;
				}
				bool flag = false;
				foreach (string item2 in list)
				{
					if (string.Equals(item2, perTrogSpecy2, StringComparison.OrdinalIgnoreCase))
					{
						flag = true;
						break;
					}
				}
				if (!flag)
				{
					list.Add(perTrogSpecy2);
				}
			}
			return string.Join(", ", list);
		}

		public static List<string> FactionCoherent(IReadOnlyList<string> pool, Func<string, string> factionOf, double roll01, out string faction, out string why)
		{
			faction = null;
			why = "";
			List<string> list = new List<string>();
			if (pool == null || pool.Count == 0)
			{
				return list;
			}
			if (factionOf == null || pool.Count == 1)
			{
				list.AddRange(pool);
				if (pool.Count == 1 && factionOf != null)
				{
					faction = factionOf(pool[0]);
				}
				why = ((factionOf == null) ? "no faction resolver — cast not narrowed" : "single-species cast");
				return list;
			}
			if (roll01 < 0.0)
			{
				roll01 = 0.0;
			}
			if (roll01 >= 1.0)
			{
				roll01 = 0.999999;
			}
			int num = (int)Math.Floor(roll01 * (double)pool.Count);
			if (num >= pool.Count)
			{
				num = pool.Count - 1;
			}
			string b = BucketKey(pool[num], factionOf);
			faction = factionOf(pool[num]);
			List<string> list2 = new List<string>();
			HashSet<string> hashSet = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
			foreach (string item in pool)
			{
				string text = BucketKey(item, factionOf);
				hashSet.Add(text);
				if (string.Equals(text, b, StringComparison.OrdinalIgnoreCase))
				{
					list.Add(item);
				}
				else
				{
					list2.Add(item);
				}
			}
			why = ((hashSet.Count <= 1) ? ("the cast is already one faction (" + (faction ?? "unknown") + ")") : (string.Format("cast pinned to faction {0} ({1} of {2} species; ", faction ?? "unknown", list.Count, pool.Count) + string.Format("{0} factions in the pool) — dropped {1} ", hashSet.Count, string.Join(", ", list2.ToArray())) + "so the party cannot fight itself"));
			return list;
		}

		public static List<string> CoherentWarmCast(IReadOnlyList<string> warm, IReadOnlyList<string> showable, Func<string, string> factionOf, double roll01, int minVariety, out string faction, out string why, out int coldAdmitted)
		{
			coldAdmitted = 0;
			if (showable == null || showable.Count == 0)
			{
				faction = null;
				why = "";
				return new List<string>();
			}
			if (warm == null || warm.Count == 0)
			{
				List<string> list = FactionCoherent(showable, factionOf, roll01, out faction, out why);
				coldAdmitted = list.Count;
				why += " (nothing warm here — the whole cast is a cold fallback)";
				return list;
			}
			if (factionOf == null)
			{
				faction = null;
				List<string> list2 = new List<string>(warm);
				coldAdmitted = TopUp(list2, showable, null, null, minVariety);
				why = "no faction resolver — cast not narrowed";
				return list2;
			}
			if (minVariety < 1)
			{
				minVariety = 1;
			}
			List<string> list3 = new List<string>();
			Dictionary<string, List<string>> dictionary = new Dictionary<string, List<string>>(StringComparer.OrdinalIgnoreCase);
			for (int i = 0; i < warm.Count; i++)
			{
				string text = warm[i];
				if (!string.IsNullOrEmpty(text))
				{
					string text2 = BucketKey(text, factionOf);
					if (!dictionary.TryGetValue(text2, out var value))
					{
						value = (dictionary[text2] = new List<string>());
						list3.Add(text2);
					}
					if (!value.Contains(text))
					{
						value.Add(text);
					}
				}
			}
			if (list3.Count == 0)
			{
				faction = null;
				why = "";
				return new List<string>();
			}
			int num = 0;
			for (int j = 0; j < list3.Count; j++)
			{
				if (dictionary[list3[j]].Count > num)
				{
					num = dictionary[list3[j]].Count;
				}
			}
			List<string> list5 = new List<string>();
			List<string> list6 = new List<string>();
			for (int k = 0; k < list3.Count; k++)
			{
				List<string> list7 = dictionary[list3[k]];
				if (list7.Count != num)
				{
					continue;
				}
				list6.Add(list3[k]);
				foreach (string item in list7)
				{
					list5.Add(item);
				}
			}
			if (roll01 < 0.0)
			{
				roll01 = 0.0;
			}
			if (roll01 >= 1.0)
			{
				roll01 = 0.999999;
			}
			int num2 = (int)Math.Floor(roll01 * (double)list5.Count);
			if (num2 >= list5.Count)
			{
				num2 = list5.Count - 1;
			}
			string text3 = BucketKey(list5[num2], factionOf);
			faction = factionOf(list5[num2]);
			List<string> list8 = new List<string>(dictionary[text3]);
			int count = list8.Count;
			coldAdmitted = TopUp(list8, showable, factionOf, text3, minVariety);
			string arg = ((list6.Count > 1) ? $"tied at {num} warm with {list6.Count} factions — rolled" : $"the warmest of {list3.Count} faction(s) in the warm pool");
			why = string.Format("cast pinned to faction {0} ({1}; {2} warm species", faction ?? "unknown", arg, count) + ((coldAdmitted > 0) ? $" + {coldAdmitted} cold from the SAME faction to reach the variety floor of {minVariety}" : "") + ") so the party cannot fight itself";
			return list8;
		}

		private static int TopUp(List<string> cast, IReadOnlyList<string> showable, Func<string, string> factionOf, string wantKey, int minVariety)
		{
			int num = 0;
			for (int i = 0; i < showable.Count; i++)
			{
				if (cast.Count >= minVariety)
				{
					break;
				}
				string text = showable[i];
				if (string.IsNullOrEmpty(text) || (factionOf != null && !string.Equals(BucketKey(text, factionOf), wantKey, StringComparison.OrdinalIgnoreCase)))
				{
					continue;
				}
				bool flag = false;
				foreach (string item in cast)
				{
					if (string.Equals(item, text, StringComparison.OrdinalIgnoreCase))
					{
						flag = true;
						break;
					}
				}
				if (!flag)
				{
					cast.Add(text);
					num++;
				}
			}
			return num;
		}

		private static string BucketKey(string species, Func<string, string> factionOf)
		{
			string text = factionOf(species);
			if (!string.IsNullOrEmpty(text))
			{
				return text;
			}
			return "?" + species;
		}

		public static int Count(int min, int max, double roll01)
		{
			if (min < 1)
			{
				min = 1;
			}
			if (max < min)
			{
				max = min;
			}
			if (roll01 < 0.0)
			{
				roll01 = 0.0;
			}
			if (roll01 >= 1.0)
			{
				roll01 = 0.999999;
			}
			return min + (int)Math.Floor(roll01 * (double)(max - min + 1));
		}

		public static int Rate(int min, int max, double roll01)
		{
			if (min < 0)
			{
				min = 0;
			}
			if (max < min)
			{
				max = min;
			}
			if (roll01 < 0.0)
			{
				roll01 = 0.0;
			}
			if (roll01 >= 1.0)
			{
				roll01 = 0.999999;
			}
			return min + (int)Math.Floor(roll01 * (double)(max - min + 1));
		}

		public static int Reward(int spawned, int deadNow, bool helped, int min, int max, double roll01)
		{
			if (!helped)
			{
				return 0;
			}
			if (spawned < 0)
			{
				spawned = 0;
			}
			if (deadNow < 0)
			{
				deadNow = 0;
			}
			if (deadNow > spawned)
			{
				deadNow = spawned;
			}
			if (deadNow == 0)
			{
				return 0;
			}
			return Rate(min, max, roll01) * deadNow;
		}

		public static string[] DealSpecies(IReadOnlyList<string> pool, int warmCount, int slots, Func<double> roll01)
		{
			if (pool == null || pool.Count == 0 || slots <= 0)
			{
				return new string[0];
			}
			if (roll01 == null)
			{
				roll01 = () => 0.0;
			}
			if (warmCount < 0)
			{
				warmCount = 0;
			}
			if (warmCount > pool.Count)
			{
				warmCount = pool.Count;
			}
			List<string> list = new List<string>(slots);
			int num = ((warmCount < slots) ? warmCount : slots);
			if (num > 0)
			{
				List<string> list2 = new List<string>(num);
				for (int num2 = 0; num2 < warmCount; num2++)
				{
					list2.Add(pool[num2]);
				}
				for (int num3 = 0; num3 < num; num3++)
				{
					int index = num3 + RollIndex(roll01(), list2.Count - num3);
					string value = list2[num3];
					list2[num3] = list2[index];
					list2[index] = value;
					list.Add(list2[num3]);
				}
			}
			while (list.Count < slots)
			{
				list.Add(PickSpecies(pool, roll01()));
			}
			string[] array = list.ToArray();
			for (int num4 = 0; num4 < array.Length - 1; num4++)
			{
				int num5 = num4 + RollIndex(roll01(), array.Length - num4);
				string text = array[num4];
				array[num4] = array[num5];
				array[num5] = text;
			}
			return array;
		}

		private static int RollIndex(double roll01, int count)
		{
			if (count <= 1)
			{
				return 0;
			}
			if (roll01 < 0.0)
			{
				roll01 = 0.0;
			}
			if (roll01 >= 1.0)
			{
				roll01 = 0.999999;
			}
			int num = (int)Math.Floor(roll01 * (double)count);
			if (num < count)
			{
				return num;
			}
			return count - 1;
		}
	}
	public enum PatrolPhase
	{
		Spawning,
		Fighting,
		Resolved,
		Leaving,
		Gone
	}
	public enum PatrolResult
	{
		None,
		GuardsWon,
		GuardsDead,
		Stalemate
	}
	public readonly struct PatrolSnapshot
	{
		public int GuardsAlive { get; }

		public int TrogsAlive { get; }

		public double SecondsFighting { get; }

		public PatrolSnapshot(int guardsAlive, int trogsAlive, double secondsFighting)
		{
			GuardsAlive = guardsAlive;
			TrogsAlive = trogsAlive;
			SecondsFighting = secondsFighting;
		}
	}
	public static class PatrolState
	{
		public static PatrolPhase Advance(PatrolPhase phase, PatrolSnapshot snap, double stalemateSeconds, out PatrolResult result)
		{
			result = PatrolResult.None;
			switch (phase)
			{
			case PatrolPhase.Spawning:
				if (snap.GuardsAlive <= 0)
				{
					result = PatrolResult.GuardsDead;
					return PatrolPhase.Resolved;
				}
				if (snap.TrogsAlive <= 0)
				{
					return PatrolPhase.Spawning;
				}
				return PatrolPhase.Fighting;
			case PatrolPhase.Fighting:
				if (snap.GuardsAlive <= 0)
				{
					result = PatrolResult.GuardsDead;
					return PatrolPhase.Resolved;
				}
				if (snap.TrogsAlive <= 0)
				{
					result = PatrolResult.GuardsWon;
					return PatrolPhase.Resolved;
				}
				if (stalemateSeconds > 0.0 && snap.SecondsFighting >= stalemateSeconds)
				{
					result = PatrolResult.Stalemate;
					return PatrolPhase.Resolved;
				}
				return PatrolPhase.Fighting;
			default:
				return phase;
			}
		}
	}
	public static class PatrolText
	{
		public const string GreetingNoHelp = "It's done. Keep to the road, and keep your eyes open — where there were these, there will be more.";

		public const string RewardChoice = "You mentioned a purse.";

		public const string AlreadyPaid = "You've had the purse. Try that again and I'll want it back.";

		public static string Greeting(string townName)
		{
			if (!Has(townName))
			{
				return "Stand clear, traveller. There is trog work on this road today, and we are paid to do it.";
			}
			return "Stand clear, traveller. " + townName + " pays us to keep this stretch of road clear of trogs, and there is work in it today.";
		}

		public static string GreetingHelped(int dead)
		{
			if (dead > 0)
			{
				return "You stood with us, and " + Trogs(dead) + " won't be crawling out of that hole again. The town keeps a purse for that sort of thing.";
			}
			return "You stood with us. That is more than most on this road would have done.";
		}

		public static string RewardReply(int silver, int dead)
		{
			if (silver > 0)
			{
				return Silver(silver) + ", figured on " + Trogs(dead) + ". Count it if you like — I did.";
			}
			return "Bounty's paid per carcass, and there's none to count. Nothing owed, but the thanks stand.";
		}

		public static string Toast(string bearing)
		{
			string text = (bearing ?? "").Trim();
			if (text.Length <= 0)
			{
				return "A town patrol is fighting troglodytes nearby.";
			}
			return "A town patrol is fighting troglodytes to the " + text + ".";
		}

		public static string Trogs(int n)
		{
			if (n != 1)
			{
				return $"{n} troglodytes";
			}
			return "1 troglodyte";
		}

		public static string Silver(int n)
		{
			return $"{n} silver";
		}

		private static bool Has(string s)
		{
			if (!string.IsNullOrEmpty(s))
			{
				return s.Trim().Length > 0;
			}
			return false;
		}
	}
	public static class PeerRepush
	{
		public static bool ShouldRepush(bool isMaster, bool directorArmed, int peerActor, int localActor)
		{
			if (!isMaster)
			{
				return false;
			}
			if (!directorArmed)
			{
				return false;
			}
			if (peerActor <= 0 || peerActor == localActor)
			{
				return false;
			}
			return true;
		}
	}
	public static class PlateauRule
	{
		public static bool Accept(bool corner0, bool corner1, bool corner2, bool corner3)
		{
			return corner0 && corner1 && corner2 && corner3;
		}

		public static bool Accept(float d0, float d1, float d2, float d3, float maxSpread)
		{
			if (d0 < 0f || d1 < 0f || d2 < 0f || d3 < 0f)
			{
				return false;
			}
			if (maxSpread <= 0f)
			{
				return true;
			}
			float num = Math.Min(Math.Min(d0, d1), Math.Min(d2, d3));
			return Math.Max(Math.Max(d0, d1), Math.Max(d2, d3)) - num <= maxSpread;
		}
	}
	public static class PlayerBody
	{
		public static bool Holds(bool playerFaction, bool isAi, bool alive)
		{
			return playerFaction && !isAi && alive;
		}
	}
	public static class PrewarmSlate
	{
		public const int ReservedForOthers = 4;

		public const int FixedCastDepth = 2;

		public static int Budget(int lruCapacity, int fallback)
		{
			if (lruCapacity <= 0)
			{
				if (fallback >= 0)
				{
					return fallback;
				}
				return 0;
			}
			int num = lruCapacity - 4;
			if (num >= 1)
			{
				return num;
			}
			return 1;
		}

		public static List<string> Compose(IReadOnlyList<IReadOnlyList<string>> sources, int perSource, int lruCapacity, Func<string, bool> alreadyWarm, out string why, IReadOnlyList<int> depths = null)
		{
			if (sources == null || perSource <= 0)
			{
				why = "nothing to warm";
				return new List<string>();
			}
			List<IReadOnlyList<string>> list = new List<IReadOnlyList<string>>(sources.Count);
			int num = 0;
			for (int i = 0; i < sources.Count; i++)
			{
				IReadOnlyList<string> readOnlyList = sources[i];
				List<string> list2 = new List<string>();
				if (readOnlyList != null)
				{
					for (int j = 0; j < readOnlyList.Count; j++)
					{
						string text = (readOnlyList[j] ?? "").Trim();
						if (text.Length != 0)
						{
							num++;
							if (alreadyWarm == null || !alreadyWarm(text))
							{
								list2.Add(text);
							}
						}
					}
				}
				list.Add(list2);
			}
			int[] array = new int[list.Count];
			for (int k = 0; k < list.Count; k++)
			{
				int num2 = ((depths != null && k < depths.Count) ? depths[k] : perSource);
				if (num2 <= 0)
				{
					num2 = perSource;
				}
				array[k] = ((num2 < perSource) ? num2 : perSource);
			}
			List<string> list3 = MergeWithDepths(list, array);
			int num3 = Budget(lruCapacity, list3.Count);
			int num4 = 0;
			if (list3.Count > num3)
			{
				num4 = list3.Count - num3;
				list3.RemoveRange(num3, num4);
			}
			why = $"{list3.Count} cold of {num} offered across {list.Count} card(s), " + string.Format("depths [{0}] of {1}, budget {2}", string.Join(",", Array.ConvertAll(array, (int c) => c.ToString())), perSource, num3) + ((lruCapacity > 0) ? $" (LRU {lruCapacity} less {4} reserved)" : " (LRU uncapped)") + ((num4 > 0) ? $" — {num4} dropped so the queue cannot evict its own head" : "");
			return list3;
		}

		private static List<string> MergeWithDepths(IReadOnlyList<IReadOnlyList<string>> sources, int[] caps)
		{
			List<string> list = new List<string>();
			HashSet<string> hashSet = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
			int num = 0;
			for (int i = 0; i < caps.Length; i++)
			{
				if (caps[i] > num)
				{
					num = caps[i];
				}
			}
			for (int j = 0; j < num; j++)
			{
				for (int k = 0; k < sources.Count; k++)
				{
					if (j >= caps[k])
					{
						continue;
					}
					IReadOnlyList<string> readOnlyList = sources[k];
					if (readOnlyList != null && j < readOnlyList.Count)
					{
						string text = (readOnlyList[j] ?? "").Trim();
						if (text.Length != 0 && hashSet.Add(text))
						{
							list.Add(text);
						}
					}
				}
			}
			return list;
		}
	}
	public sealed class ColdNote
	{
		public string What { get; }

		public string Species { get; }

		public string Reason { get; }

		public int[] Actors { get; }

		public ColdNote(string? what, string? species, string? reason, int[]? actors)
		{
			What = (what ?? "encounter").Trim();
			Species = (species ?? "").Trim();
			Reason = (reason ?? "").Trim();
			Actors = actors ?? new int[0];
		}
	}
	public static class QuietRoads
	{
		public const double DefaultMinGapSeconds = 60.0;

		public const double Never = double.NegativeInfinity;

		public static string KeyFor(string? region, IReadOnlyList<ColdNote>? notes)
		{
			if (notes == null || notes.Count == 0)
			{
				return "";
			}
			List<string> list = new List<string>(notes.Count);
			for (int i = 0; i < notes.Count; i++)
			{
				ColdNote coldNote = notes[i];
				if (coldNote != null && coldNote.Species.Length != 0)
				{
					List<int> list2 = new List<int>(coldNote.Actors);
					list2.Sort();
					list.Add(coldNote.Species.ToLowerInvariant() + "=" + coldNote.Reason + "[" + string.Join(",", list2.ConvertAll((int a) => a.ToString()).ToArray()) + "]");
				}
			}
			if (list.Count == 0)
			{
				return "";
			}
			list.Sort(StringComparer.Ordinal);
			return (region ?? "").Trim() + "|" + string.Join(";", list.ToArray());
		}

		public static int[] PeersIn(IReadOnlyList<ColdNote>? notes)
		{
			List<int> list = new List<int>();
			if (notes == null)
			{
				return list.ToArray();
			}
			for (int i = 0; i < notes.Count; i++)
			{
				ColdNote coldNote = notes[i];
				if (coldNote == null)
				{
					continue;
				}
				for (int j = 0; j < coldNote.Actors.Length; j++)
				{
					if (!list.Contains(coldNote.Actors[j]))
					{
						list.Add(coldNote.Actors[j]);
					}
				}
			}
			list.Sort();
			return list.ToArray();
		}

		public static List<string> SpeciesIn(IReadOnlyList<ColdNote>? notes)
		{
			List<string> list = new List<string>();
			if (notes == null)
			{
				return list;
			}
			for (int i = 0; i < notes.Count; i++)
			{
				ColdNote coldNote = notes[i];
				if (coldNote == null || coldNote.Species.Length == 0)
				{
					continue;
				}
				bool flag = false;
				for (int j = 0; j < list.Count; j++)
				{
					if (string.Equals(list[j], coldNote.Species, StringComparison.OrdinalIgnoreCase))
					{
						flag = true;
						break;
					}
				}
				if (!flag)
				{
					list.Add(coldNote.Species);
				}
			}
			return list;
		}

		public static bool ShouldLog(string? key, string? lastKey, double now, double lastAt, double minGapSeconds)
		{
			if (string.IsNullOrEmpty(key))
			{
				return false;
			}
			if (!string.Equals(key, lastKey ?? "", StringComparison.Ordinal))
			{
				return true;
			}
			if (double.IsNaN(now) || double.IsInfinity(now))
			{
				return false;
			}
			if (double.IsNaN(lastAt) || double.IsInfinity(lastAt))
			{
				return true;
			}
			if (minGapSeconds <= 0.0)
			{
				return true;
			}
			return now - lastAt >= minGapSeconds;
		}

		public static bool ShouldToast(string? region, string? lastToastRegion)
		{
			string text = (region ?? "").Trim();
			if (text.Length == 0)
			{
				return false;
			}
			return !string.Equals(text, (lastToastRegion ?? "").Trim(), StringComparison.Ordinal);
		}

		public static string Describe(string? region, IReadOnlyList<ColdNote>? notes)
		{
			if (notes == null || notes.Count == 0)
			{
				return "";
			}
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.Append("co-op encounters refused in '").Append(string.IsNullOrEmpty(region) ? "unknown region" : region).Append("': ");
			bool flag = true;
			for (int i = 0; i < notes.Count; i++)
			{
				ColdNote coldNote = notes[i];
				if (coldNote == null || coldNote.Species.Length == 0)
				{
					continue;
				}
				if (!flag)
				{
					stringBuilder.Append(", ");
				}
				flag = false;
				stringBuilder.Append(coldNote.Species).Append(" (").Append(coldNote.What)
					.Append("; ")
					.Append(coldNote.Reason);
				if (coldNote.Actors.Length != 0)
				{
					stringBuilder.Append("; actor").Append((coldNote.Actors.Length == 1) ? " " : "s ").Append(string.Join(",", Array.ConvertAll(coldNote.Actors, (int a) => a.ToString())));
				}
				stringBuilder.Append(')');
			}
			if (flag)
			{
				return "";
			}
			int[] array = PeersIn(notes);
			stringBuilder.Append(". Cold peer").Append((array.Length == 1) ? " " : "s ").Append((array.Length == 0) ? "unknown" : string.Join(",", Array.ConvertAll(array, (int a) => a.ToString())))
				.Append(" — 'skwarmdump' on the host prints each peer's row. ")
				.Append("THIS IS NOT A REGRESSION: the party is being asked to warm these species and the ")
				.Append("encounters come back when it can. [Coop] RoomWarmMode in cobalt.spawnkit.cfg governs ")
				.Append("how strict this is; [Coop] AnnounceQuietRoads in cobalt.dangerousroads.cfg shows the ")
				.Append("player a one-line toast.");
			return stringBuilder.ToString();
		}

		public static string Toast(int speciesCount)
		{
			if (speciesCount > 0)
			{
				return $"The roads are quiet — a companion's world is still warming ({speciesCount} species).";
			}
			return "";
		}
	}
	public struct QuietFlush
	{
		public bool Log;

		public string Line;

		public bool Toast;

		public string ToastText;

		public int SpeciesCount;

		public List<string> Cleared;
	}
	public sealed class QuietRoadsLedger
	{
		private readonly Dictionary<string, ColdNote> _pending = new Dictionary<string, ColdNote>(StringComparer.OrdinalIgnoreCase);

		private string _region = "";

		private string _lastKey = "";

		private double _lastAt = double.NegativeInfinity;

		private string _lastToastRegion = "";

		public double MinGapSeconds = 60.0;

		public int PendingCount => _pending.Count;

		public void Record(string? region, string? what, string? species, string? reason, int[]? actors)
		{
			string text = (region ?? "").Trim();
			string text2 = (species ?? "").Trim();
			if (text2.Length != 0)
			{
				if (!string.Equals(text, _region, StringComparison.Ordinal))
				{
					_pending.Clear();
					_region = text;
					_lastKey = "";
				}
				_pending[text2] = new ColdNote(what, text2, reason, actors);
			}
		}

		public QuietFlush Flush(double now, Func<string, string, ColdNote?>? refresh, bool announce)
		{
			QuietFlush result = new QuietFlush
			{
				Line = "",
				ToastText = "",
				Cleared = new List<string>()
			};
			if (refresh != null && _pending.Count > 0)
			{
				List<string> list = new List<string>(_pending.Keys);
				for (int i = 0; i < list.Count; i++)
				{
					ColdNote coldNote = _pending[list[i]];
					ColdNote coldNote2 = null;
					bool flag = false;
					try
					{
						coldNote2 = refresh(coldNote.What, coldNote.Species);
					}
					catch
					{
						flag = true;
					}
					if (!flag)
					{
						if (coldNote2 == null)
						{
							_pending.Remove(list[i]);
							result.Cleared.Add(coldNote.Species);
						}
						else
						{
							_pending[list[i]] = coldNote2;
						}
					}
				}
			}
			List<ColdNote> notes = new List<ColdNote>(_pending.Values);
			string text = QuietRoads.KeyFor(_region, notes);
			if (!QuietRoads.ShouldLog(text, _lastKey, now, _lastAt, MinGapSeconds))
			{
				if (text.Length == 0)
				{
					_lastKey = "";
				}
				return result;
			}
			_lastKey = text;
			_lastAt = now;
			result.Log = true;
			result.Line = QuietRoads.Describe(_region, notes);
			result.SpeciesCount = QuietRoads.SpeciesIn(notes).Count;
			if (!announce)
			{
				return result;
			}
			if (!QuietRoads.ShouldToast(_region, _lastToastRegion))
			{
				return result;
			}
			string text2 = QuietRoads.Toast(result.SpeciesCount);
			if (text2.Length == 0)
			{
				return result;
			}
			_lastToastRegion = _region;
			result.Toast = true;
			result.ToastText = text2;
			return result;
		}
	}
	public readonly struct RaidCandidate
	{
		public string Key { get; }

		public string Faction { get; }

		public RaidCandidate(string key, string faction)
		{
			Key = key;
			Faction = faction;
		}
	}
	public static class RaidPlan
	{
		public const string BanditFaction = "Bandits";

		public const string MerchantFaction = "Merchants";

		public const string PlayerFaction = "Player";

		public static bool Roll(double roll01, float chance)
		{
			if (chance <= 0f)
			{
				return false;
			}
			if (chance >= 1f)
			{
				return true;
			}
			return roll01 < (double)chance;
		}

		public static int Count(int min, int max, double roll01)
		{
			if (min < 1)
			{
				min = 1;
			}
			if (max < min)
			{
				max = min;
			}
			if (roll01 < 0.0)
			{
				roll01 = 0.0;
			}
			if (roll01 >= 1.0)
			{
				roll01 = 0.999999;
			}
			return min + (int)Math.Floor(roll01 * (double)(max - min + 1));
		}

		public static string PickSpecies(IReadOnlyList<RaidCandidate> roster, double roll01)
		{
			if (roster == null || roster.Count == 0)
			{
				return null;
			}
			List<string> list = new List<string>();
			List<string> list2 = new List<string>();
			List<string> list3 = new List<string>();
			for (int i = 0; i < roster.Count; i++)
			{
				RaidCandidate raidCandidate = roster[i];
				if (!string.IsNullOrEmpty(raidCandidate.Key))
				{
					if (raidCandidate.Faction == null)
					{
						list3.Add(raidCandidate.Key);
					}
					else if (string.Equals(raidCandidate.Faction, "Bandits", StringComparison.OrdinalIgnoreCase))
					{
						list.Add(raidCandidate.Key);
					}
					else if (!string.Equals(raidCandidate.Faction, "Merchants", StringComparison.OrdinalIgnoreCase) && !string.Equals(raidCandidate.Faction, "Player", StringComparison.OrdinalIgnoreCase))
					{
						list2.Add(raidCandidate.Key);
					}
				}
			}
			List<string> list4 = ((list.Count > 0) ? list : ((list2.Count > 0) ? list2 : list3));
			if (list4.Count == 0)
			{
				return null;
			}
			if (roll01 < 0.0)
			{
				roll01 = 0.0;
			}
			if (roll01 >= 1.0)
			{
				roll01 = 0.999999;
			}
			return list4[(int)Math.Floor(roll01 * (double)list4.Count)];
		}

		public static bool ShouldTrigger(double playerDistance, float triggerMeters, double spawnedAt, double now, float delaySeconds, float farParkMeters = 0f)
		{
			if (triggerMeters > 0f && playerDistance >= 0.0 && playerDistance <= (double)triggerMeters)
			{
				return true;
			}
			if (delaySeconds > 0f && now - spawnedAt >= (double)delaySeconds)
			{
				if (farParkMeters > 0f && playerDistance > (double)farParkMeters)
				{
					return false;
				}
				return true;
			}
			return false;
		}

		public static int CapToRoom(int wanted, int maxOwnActive, int ownActive)
		{
			if (wanted < 0)
			{
				wanted = 0;
			}
			int num = maxOwnActive - ownActive;
			if (num < 0)
			{
				num = 0;
			}
			if (wanted >= num)
			{
				return num;
			}
			return wanted;
		}

		public static bool IsWon(int placed, int aliveRaiders)
		{
			if (placed > 0)
			{
				return aliveRaiders <= 0;
			}
			return false;
		}

		public static float Radius(float min, float max, double roll01)
		{
			if (min < 0f)
			{
				min = 0f;
			}
			if (max < min)
			{
				max = min;
			}
			if (roll01 < 0.0)
			{
				roll01 = 0.0;
			}
			if (roll01 > 1.0)
			{
				roll01 = 1.0;
			}
			return min + (float)(roll01 * (double)(max - min));
		}
	}
	public enum RegionArmAction
	{
		Keep,
		Rearm,
		Disarm
	}
	public static class RegionArmGate
	{
		public static RegionArmAction Decide(bool isOverworld, string builtForScene, string activeScene, bool hasPlayer)
		{
			if (!isOverworld)
			{
				return RegionArmAction.Keep;
			}
			string text = builtForScene ?? "";
			string b = activeScene ?? "";
			if (text.Length > 0 && string.Equals(text, b, StringComparison.Ordinal))
			{
				return RegionArmAction.Keep;
			}
			if (!hasPlayer)
			{
				return RegionArmAction.Disarm;
			}
			return RegionArmAction.Rearm;
		}
	}
	public enum GateVerdict
	{
		Ok,
		Disabled,
		NoArea,
		NotOverworld,
		TownOrCity
	}
	public enum ZoneKind
	{
		None,
		Overworld,
		City,
		Dungeon
	}
	public static class RegionGate
	{
		public static readonly int[] OverworldAreaIds = new int[6] { 101, 201, 301, 401, 501, 602 };

		public static ZoneKind ZoneOf(GateVerdict verdict)
		{
			return verdict switch
			{
				GateVerdict.Ok => ZoneKind.Overworld, 
				GateVerdict.TownOrCity => ZoneKind.City, 
				GateVerdict.NotOverworld => ZoneKind.Dungeon, 
				_ => ZoneKind.None, 
			};
		}

		public static bool IsOverworldArea(int areaId)
		{
			for (int i = 0; i < OverworldAreaIds.Length; i++)
			{
				if (OverworldAreaIds[i] == areaId)
				{
					return true;
				}
			}
			return false;
		}

		public static GateVerdict Evaluate(bool enabled, int? areaId, bool townOrCity)
		{
			if (!enabled)
			{
				return GateVerdict.Disabled;
			}
			if (!areaId.HasValue)
			{
				return GateVerdict.NoArea;
			}
			if (townOrCity)
			{
				return GateVerdict.TownOrCity;
			}
			if (!IsOverworldArea(areaId.Value))
			{
				return GateVerdict.NotOverworld;
			}
			return GateVerdict.Ok;
		}
	}
	public enum RejectReason
	{
		None,
		OutOfBand,
		InSight,
		NoNavSample,
		NoPath,
		PathIncomplete,
		RatioTooHigh,
		Plateau,
		TooCloseToMember,
		SourceEmpty,
		Hazard,
		Roofed
	}
	public static class RoadChain
	{
		public const double DefaultHopMeters = 120.0;

		public const double DefaultMinAdvanceMeters = 10.0;

		public const int DefaultMaxWaypoints = 64;

		public static List<XZ> Chain(XZ spawn, XZ exit, IReadOnlyList<XZ> seeds, double hopMeters = 120.0, double minAdvanceMeters = 10.0, int maxWaypoints = 64)
		{
			List<XZ> list = new List<XZ>();
			if (seeds == null || seeds.Count == 0 || hopMeters <= 0.0)
			{
				return list;
			}
			if (minAdvanceMeters < 0.0)
			{
				minAdvanceMeters = 0.0;
			}
			if (maxWaypoints < 1)
			{
				maxWaypoints = 1;
			}
			bool[] array = new bool[seeds.Count];
			XZ xZ = spawn;
			double num = XZ.Distance(xZ, exit);
			while (list.Count < maxWaypoints && num > hopMeters)
			{
				int num2 = -1;
				double num3 = double.MaxValue;
				for (int i = 0; i < seeds.Count; i++)
				{
					if (!array[i])
					{
						double num4 = XZ.Distance(xZ, seeds[i]);
						if (!(num4 > hopMeters) && !(num4 >= num3) && !(XZ.Distance(seeds[i], exit) > num - minAdvanceMeters))
						{
							num2 = i;
							num3 = num4;
						}
					}
				}
				if (num2 < 0)
				{
					break;
				}
				array[num2] = true;
				xZ = seeds[num2];
				num = XZ.Distance(xZ, exit);
				list.Add(xZ);
			}
			return list;
		}
	}
	public readonly struct XZ
	{
		public double X { get; }

		public double Z { get; }

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

		public static double Distance(XZ a, XZ b)
		{
			double num = b.X - a.X;
			double num2 = b.Z - a.Z;
			return Math.Sqrt(num * num + num2 * num2);
		}

		public override string ToString()
		{
			return $"({X:F1}, {Z:F1})";
		}
	}
	public static class RoadRoute
	{
		public static int ChooseExit(XZ spawn, IReadOnlyList<XZ> exits, double minRouteMeters, double roll01)
		{
			if (exits == null || exits.Count == 0)
			{
				return -1;
			}
			List<int> list = new List<int>();
			int result = 0;
			double num = -1.0;
			for (int i = 0; i < exits.Count; i++)
			{
				double num2 = XZ.Distance(spawn, exits[i]);
				if (num2 >= minRouteMeters)
				{
					list.Add(i);
				}
				if (num2 > num)
				{
					num = num2;
					result = i;
				}
			}
			if (list.Count == 0)
			{
				return result;
			}
			return list[IndexFor(roll01, list.Count)];
		}

		public static List<XZ> ThreadSeeds(XZ spawn, XZ exit, IReadOnlyList<XZ> seeds, double corridorMeters)
		{
			List<(double, int, XZ)> list = new List<(double, int, XZ)>();
			if (seeds == null || seeds.Count == 0)
			{
				return new List<XZ>();
			}
			double num = exit.X - spawn.X;
			double num2 = exit.Z - spawn.Z;
			double num3 = num * num + num2 * num2;
			if (num3 <= 1E-09)
			{
				return new List<XZ>();
			}
			double num4 = Math.Sqrt(num3);
			for (int i = 0; i < seeds.Count; i++)
			{
				double num5 = seeds[i].X - spawn.X;
				double num6 = seeds[i].Z - spawn.Z;
				double num7 = (num5 * num + num6 * num2) / num3;
				if (!(num7 <= 0.0) && !(num7 >= 1.0) && !(Math.Abs(num5 * num2 - num6 * num) / num4 > corridorMeters))
				{
					list.Add((num7, i, seeds[i]));
				}
			}
			list.Sort(delegate((double T, int Index, XZ Seed) a, (double T, int Index, XZ Seed) b)
			{
				int num9 = a.T.CompareTo(b.T);
				return (num9 == 0) ? a.Index.CompareTo(b.Index) : num9;
			});
			List<XZ> list2 = new List<XZ>(list.Count);
			for (int num8 = 0; num8 < list.Count; num8++)
			{
				list2.Add(list[num8].Item3);
			}
			return list2;
		}

		public static List<XZ> KeepReachable(XZ from, IReadOnlyList<XZ> seeds, Func<XZ, XZ, bool> canWalk, List<XZ> dropped = null)
		{
			List<XZ> list = new List<XZ>();
			if (seeds == null || seeds.Count == 0)
			{
				return list;
			}
			if (canWalk == null)
			{
				list.AddRange(seeds);
				return list;
			}
			XZ arg = from;
			for (int i = 0; i < seeds.Count; i++)
			{
				if (canWalk(arg, seeds[i]))
				{
					list.Add(seeds[i]);
					arg = seeds[i];
				}
				else
				{
					dropped?.Add(seeds[i]);
				}
			}
			return list;
		}

		public static List<XZ> Build(XZ spawn, XZ exit, IReadOnlyList<XZ> seeds, double corridorMeters)
		{
			List<XZ> list = ThreadSeeds(spawn, exit, seeds, corridorMeters);
			list.Add(exit);
			return list;
		}

		public static bool NextWaypoint(XZ pos, IReadOnlyList<XZ> route, double arriveRadius, ref int index, out XZ target)
		{
			target = default(XZ);
			if (route == null || route.Count == 0)
			{
				return false;
			}
			if (index < 0)
			{
				index = 0;
			}
			int num = route.Count - 1;
			if (index > num)
			{
				index = num;
			}
			for (int num2 = num; num2 >= index; num2--)
			{
				if (Arrived(pos, route[num2], arriveRadius))
				{
					index = ((num2 + 1 > num) ? num : (num2 + 1));
					break;
				}
			}
			target = route[index];
			return true;
		}

		public static bool Arrived(XZ pos, XZ exit, double radius)
		{
			if (radius > 0.0)
			{
				return XZ.Distance(pos, exit) <= radius;
			}
			return false;
		}

		private static int IndexFor(double roll01, int count)
		{
			if (count <= 0)
			{
				return 0;
			}
			if (roll01 < 0.0)
			{
				roll01 = 0.0;
			}
			if (roll01 > 1.0)
			{
				roll01 = 1.0;
			}
			int num = (int)(roll01 * (double)count);
			if (num < count)
			{
				return num;
			}
			return count - 1;
		}
	}
	public enum SpeciesSource
	{
		DonorTable,
		SquadReserve,
		Nearby
	}
	public sealed class SpeciesCandidate
	{
		public string Key { get; }

		public SpeciesSource Source { get; }

		public bool Blocked { get; }

		public bool ExpeditionOnly { get; }