using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Text;
using 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("CompanionKit.Core")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("0.4.20.0")]
[assembly: AssemblyInformationalVersion("0.4.20+091b206910305beb491301afe1db01b8cd7b8e72")]
[assembly: AssemblyProduct("CompanionKit.Core")]
[assembly: AssemblyTitle("CompanionKit.Core")]
[assembly: AssemblyMetadata("BuildStamp", "091b2069 2026-08-28")]
[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 CompanionKit.Core
{
	public static class AgentFit
	{
		public const float MaxBaseOffset = 3f;

		public static float BaseOffset(float pivotY, float boundsMinY)
		{
			float num = pivotY - boundsMinY;
			if (float.IsNaN(num) || num < 0f)
			{
				return 0f;
			}
			if (!(num > 3f))
			{
				return num;
			}
			return 3f;
		}
	}
	public enum AnchorGlueMode
	{
		Off,
		Combat,
		Always
	}
	public enum AnchorGlueAction
	{
		None,
		Write,
		SafeTeleport,
		AgentWarp
	}
	public static class AnchorGlue
	{
		public const float SafeTeleportGap = 2f;

		public static bool Engaged(AnchorGlueMode mode, bool hasBody, bool inCombat)
		{
			if (!hasBody)
			{
				return false;
			}
			return mode switch
			{
				AnchorGlueMode.Always => true, 
				AnchorGlueMode.Combat => inCombat, 
				_ => false, 
			};
		}

		public static bool LeashApplies(AnchorGlueMode mode, bool hasBody, bool inCombat, bool externallyDriven)
		{
			if (!externallyDriven)
			{
				return !Engaged(mode, hasBody, inCombat);
			}
			return false;
		}

		public static AnchorGlueAction Decide(AnchorGlueMode mode, bool hasBody, bool inCombat, bool anchorAlive, bool isMasterClient, bool positionsSane, bool agentDrivesTransform, float separation)
		{
			if (!Engaged(mode, hasBody, inCombat))
			{
				return AnchorGlueAction.None;
			}
			if (!anchorAlive || !isMasterClient || !positionsSane)
			{
				return AnchorGlueAction.None;
			}
			if (agentDrivesTransform)
			{
				return AnchorGlueAction.AgentWarp;
			}
			if (!(separation > 2f))
			{
				return AnchorGlueAction.Write;
			}
			return AnchorGlueAction.SafeTeleport;
		}

		public static void WeldPosition(float puppetX, float puppetY, float puppetZ, float facingX, float facingZ, float offsetBehind, out float x, out float y, out float z)
		{
			y = puppetY;
			double num = Math.Sqrt((double)facingX * (double)facingX + (double)facingZ * (double)facingZ);
			if (num < 1E-06 || offsetBehind == 0f)
			{
				x = puppetX;
				z = puppetZ;
			}
			else
			{
				x = puppetX - (float)((double)facingX / num * (double)offsetBehind);
				z = puppetZ - (float)((double)facingZ / num * (double)offsetBehind);
			}
		}

		public static bool ShouldAssertLock(bool unifyEnabled, bool petHasTarget, bool anchorAlive, bool anchorLockIsSameTarget)
		{
			if (unifyEnabled && petHasTarget && anchorAlive)
			{
				return !anchorLockIsSameTarget;
			}
			return false;
		}
	}
	public enum AnchorCollisionMode
	{
		Block,
		PassPlayer,
		Phantom
	}
	public enum AnchorPhysAction
	{
		None,
		Stamp,
		Unstamp,
		Restamp
	}
	public static class AnchorPhysicsPolicy
	{
		public static AnchorPhysAction Decide(AnchorCollisionMode mode, bool weStampedBefore, bool ignoredNow, bool collidersReady)
		{
			if (!collidersReady)
			{
				return AnchorPhysAction.None;
			}
			switch (mode)
			{
			case AnchorCollisionMode.Block:
				if (!(weStampedBefore && ignoredNow))
				{
					return AnchorPhysAction.None;
				}
				return AnchorPhysAction.Unstamp;
			case AnchorCollisionMode.Phantom:
				return AnchorPhysAction.None;
			default:
				if (ignoredNow)
				{
					return AnchorPhysAction.None;
				}
				if (!weStampedBefore)
				{
					return AnchorPhysAction.Stamp;
				}
				return AnchorPhysAction.Restamp;
			}
		}
	}
	public struct AnchorReplicaPlan
	{
		public bool LocalOwner;

		public bool NeutralizeLifetime;

		public bool RetuneNetConvergence;

		public bool HideRenderers;

		public bool MuteAudio;

		public bool NeuterWeapon;

		public bool KillHealthBar;

		public bool ExemptPlayerCollision;

		public string LogScope;
	}
	public static class AnchorReplicaPolicy
	{
		public const string ForeignScope = "foreign anchor";

		public const string OwnScope = "own-pet anchor replica";

		public static AnchorReplicaPlan For(bool localOwner)
		{
			return new AnchorReplicaPlan
			{
				LocalOwner = localOwner,
				NeutralizeLifetime = true,
				RetuneNetConvergence = true,
				HideRenderers = true,
				MuteAudio = true,
				NeuterWeapon = true,
				KillHealthBar = true,
				ExemptPlayerCollision = true,
				LogScope = (localOwner ? "own-pet anchor replica" : "foreign anchor")
			};
		}
	}
	public static class AnchorVitals
	{
		public static float RestoreHealth(double frac, double max)
		{
			if (double.IsNaN(frac) || double.IsInfinity(frac))
			{
				frac = 1.0;
			}
			if (!(max > 0.0) || double.IsInfinity(max))
			{
				return 0f;
			}
			if (frac >= 1.0)
			{
				return (float)max;
			}
			double num = Math.Round(((frac < 0.0) ? 0.0 : frac) * max);
			if (num < 1.0)
			{
				num = 1.0;
			}
			if (num > max)
			{
				num = max;
			}
			return (float)num;
		}
	}
	public static class AnimParamLatch
	{
		public static bool IsAnswer(int parameterCount)
		{
			return parameterCount > 0;
		}

		public static bool ShouldProbe(bool latched, int parameterCount)
		{
			if (!latched)
			{
				return IsAnswer(parameterCount);
			}
			return false;
		}

		public static bool Latch(bool latched, int parameterCount)
		{
			if (!latched)
			{
				return IsAnswer(parameterCount);
			}
			return true;
		}

		public static bool ShouldLatchCensus(bool found, bool allAnswered)
		{
			return found || allAnswered;
		}
	}
	public enum AuraCaptureState
	{
		NotNeeded,
		Pending,
		InFlight,
		Captured,
		Failed
	}
	public static class AuraBook
	{
		public const int SlotBase = 100;

		public const string KeyPrefix = "aura.";

		public static bool IsAuraKey(string key)
		{
			if (!string.IsNullOrEmpty(key) && key.StartsWith("aura.", StringComparison.OrdinalIgnoreCase))
			{
				return key.Length > "aura.".Length;
			}
			return false;
		}

		public static string ValidateRegistration(string key, int slot, IEnumerable<string> existingKeys, IEnumerable<int> existingSlots)
		{
			if (!IsAuraKey(key))
			{
				return "aura key '" + (key ?? "<null>") + "' is not legal — keys must be 'aura.<name>'.";
			}
			if (slot < 100)
			{
				return $"aura '{key}' slot {slot} is below the reserved aura band (must be >= {100} — " + "slots below it belong to consumer spell tables).";
			}
			if (existingKeys != null)
			{
				foreach (string existingKey in existingKeys)
				{
					if (string.Equals(existingKey, key, StringComparison.OrdinalIgnoreCase))
					{
						return "aura key '" + key + "' is already registered.";
					}
				}
			}
			if (existingSlots != null)
			{
				foreach (int existingSlot in existingSlots)
				{
					if (existingSlot == slot)
					{
						return $"aura '{key}' slot {slot} is already taken by another aura.";
					}
				}
			}
			return null;
		}

		public static List<string> FilterCandidates(string filter)
		{
			List<string> list = new List<string>();
			if (string.IsNullOrEmpty(filter))
			{
				return list;
			}
			string[] array = filter.Split(new char[1] { ',' });
			for (int i = 0; i < array.Length; i++)
			{
				string text = array[i].Trim();
				if (text.Length > 0)
				{
					list.Add(text);
				}
			}
			return list;
		}

		public static bool MatchesFilter(string nodeName, IReadOnlyList<string> candidates)
		{
			if (string.IsNullOrEmpty(nodeName) || candidates == null)
			{
				return false;
			}
			for (int i = 0; i < candidates.Count; i++)
			{
				if (nodeName.IndexOf(candidates[i], StringComparison.OrdinalIgnoreCase) >= 0)
				{
					return true;
				}
			}
			return false;
		}

		public static int SelectCaptureDepth(IReadOnlyList<string> leafToRootNames, IReadOnlyList<string> candidates)
		{
			if (leafToRootNames == null)
			{
				return -1;
			}
			for (int i = 0; i < leafToRootNames.Count; i++)
			{
				if (MatchesFilter(leafToRootNames[i], candidates))
				{
					return i;
				}
			}
			return -1;
		}

		public static string CaptureKey(string speciesKey, string filter)
		{
			return (speciesKey ?? "").Trim().ToLowerInvariant() + "|" + (filter ?? "").Trim().ToLowerInvariant();
		}
	}
	public static class BodyFxDescribe
	{
		public const string NoRenderer = "NONE";

		private static string Or(string s, string fallback)
		{
			if (!string.IsNullOrEmpty(s))
			{
				return s;
			}
			return fallback;
		}

		public static string Played(string spellKey, string verb, string target, string source)
		{
			return "played '" + Or(spellKey, "?") + "' via " + Or(verb, "?") + " on " + Or(target, "?") + " src=" + Or(source, "?");
		}

		public static string Binding(string componentType, string node, string rendererName)
		{
			return Or(componentType, "?") + "@" + Or(node, "?") + " -> renderer=" + Or(rendererName, "NONE");
		}

		public static string Bindings(IEnumerable<string> fragments)
		{
			if (fragments == null)
			{
				return "";
			}
			StringBuilder stringBuilder = new StringBuilder();
			foreach (string fragment in fragments)
			{
				if (!string.IsNullOrEmpty(fragment))
				{
					if (stringBuilder.Length > 0)
					{
						stringBuilder.Append(", ");
					}
					stringBuilder.Append(fragment);
				}
			}
			return stringBuilder.ToString();
		}
	}
	public static class BodyFxMath
	{
		public const float MinSeconds = 0.5f;

		public const float MaxSeconds = 10f;

		public const float EncaseAuthoredHeight = 2f;

		public const float EncaseMinFactor = 0.3f;

		public const float EncaseMaxFactor = 4f;

		public const float TopYFloor = 0.2f;

		public const float TopYDefault = 1.5f;

		public static float ClampSeconds(float seconds)
		{
			if (!(seconds > 0.5f))
			{
				return 0.5f;
			}
			if (!(seconds > 10f))
			{
				return seconds;
			}
			return 10f;
		}

		public static float EncaseScale(float sizeX, float sizeY, float sizeZ, float userScale)
		{
			float num = Math.Max(SaneDim(sizeX), Math.Max(SaneDim(sizeY), SaneDim(sizeZ)));
			float num2 = ((userScale > 0f) ? userScale : 1f);
			float num3 = num / 2f * num2;
			if (!(num3 > 0.3f))
			{
				return 0.3f;
			}
			if (!(num3 > 4f))
			{
				return num3;
			}
			return 4f;
		}

		public static bool FlattenForward(float fx, float fz, out float nx, out float nz)
		{
			if (!float.IsNaN(fx) && !float.IsNaN(fz) && EffigyPinMath.HorizontalFacing(fx, fz, out nx, out nz))
			{
				return true;
			}
			nx = 0f;
			nz = 1f;
			return false;
		}

		public static float TopY(float boundsMaxY, float bodyY)
		{
			float num = boundsMaxY - bodyY;
			if (float.IsNaN(num) || float.IsInfinity(num))
			{
				return 1.5f;
			}
			if (!(num < 0.2f))
			{
				return num;
			}
			return 0.2f;
		}

		public static string Signature(int source, string statusName, int skillItemId, int attach, float offX, float offY, float offZ, float scale, float seconds, int soundId)
		{
			CultureInfo invariantCulture = CultureInfo.InvariantCulture;
			return string.Join("|", source.ToString(invariantCulture), statusName ?? "", skillItemId.ToString(invariantCulture), attach.ToString(invariantCulture), offX.ToString("G9", invariantCulture), offY.ToString("G9", invariantCulture), offZ.ToString("G9", invariantCulture), scale.ToString("G9", invariantCulture), seconds.ToString("G9", invariantCulture), soundId.ToString(invariantCulture));
		}

		public static string Signature(int source, string statusName, int skillItemId, int attach, float offX, float offY, float offZ, float scale, float seconds, int soundId, string speciesKey, string subtreeFilter)
		{
			string text = Signature(source, statusName, skillItemId, attach, offX, offY, offZ, scale, seconds, soundId);
			if (string.IsNullOrEmpty(speciesKey) && string.IsNullOrEmpty(subtreeFilter))
			{
				return text;
			}
			return text + "|" + speciesKey + "|" + subtreeFilter;
		}

		private static float SaneDim(float v)
		{
			if (float.IsNaN(v) || float.IsInfinity(v) || v < 0f)
			{
				return 0f;
			}
			return v;
		}

		public static bool SelfPlayNeedsRebind(bool rendererResolved, bool bodySmrAvailable)
		{
			return !rendererResolved && bodySmrAvailable;
		}
	}
	public enum ReapVerdict
	{
		Keep,
		Warn,
		Reap
	}
	public static class BodyReaperPolicy
	{
		public const float DefaultGraceSeconds = 90f;

		public const float DefaultCondemnSeconds = 20f;

		public static ReapVerdict Decide(float ageSeconds, bool claimedNow, float unclaimedForSeconds, bool reapEnabled, float graceSeconds = 90f, float condemnSeconds = 20f, bool everClaimed = true, bool warnedAlready = false)
		{
			if (claimedNow)
			{
				return ReapVerdict.Keep;
			}
			if (ageSeconds < graceSeconds)
			{
				return ReapVerdict.Keep;
			}
			if (unclaimedForSeconds < condemnSeconds)
			{
				return ReapVerdict.Warn;
			}
			if (!everClaimed && !warnedAlready)
			{
				return ReapVerdict.Warn;
			}
			if (!reapEnabled)
			{
				return ReapVerdict.Warn;
			}
			return ReapVerdict.Reap;
		}
	}
	public enum CombatStyle
	{
		Chase,
		Opposite
	}
	public sealed class CombatStationTuning
	{
		public float RingFraction = 0.6f;

		public float LineAngleDeg = 20f;

		public float RestationMeters = 3f;

		public float RestationSeconds = 2f;

		public float ArriveMeters = 0.8f;

		public int MaxRestations = 6;

		public float FarMeters = 3f;

		public float ProgressMeters = 1f;

		public float EnemyFastMetersPerSecond;
	}
	public struct CombatStationState
	{
		public bool Has;

		public float X;

		public float Z;

		public float EnemyAtX;

		public float EnemyAtZ;

		public float LastAt;

		public int Restations;

		public int Reaches;

		public bool CapFallback;

		public string LastWhy;

		public float LastStationDist;

		public int Stalls;

		public int FastHolds;

		public float LastFastHoldAt;
	}
	public static class CombatStation
	{
		public const string WhyFirst = "first";

		public const string WhyCorridor = "corridor";

		public const string WhyCap = "cap";

		public const string WhyNear = "near";

		public const string WhyFar = "far";

		public const string WhyReach = "reach";

		public const string WhyStalled = "stalled";

		public const float SettleSlackMeters = 0.5f;

		public const float ReachSlackMeters = 0.5f;

		public static bool Decide(ref CombatStationState s, float enemyX, float enemyZ, float ownerX, float ownerZ, float petX, float petZ, float attackRange, float now, CombatStationTuning t)
		{
			return Decide(ref s, enemyX, enemyZ, ownerX, ownerZ, petX, petZ, attackRange, now, t, float.NaN);
		}

		public static bool Decide(ref CombatStationState s, float enemyX, float enemyZ, float ownerX, float ownerZ, float petX, float petZ, float attackRange, float now, CombatStationTuning t, float enemySpeed)
		{
			if (t == null)
			{
				t = new CombatStationTuning();
			}
			if (s.CapFallback)
			{
				return false;
			}
			float num = attackRange * t.RingFraction;
			if (!s.Has)
			{
				Place(ref s, enemyX, enemyZ, ownerX, ownerZ, petX, petZ, num);
				s.Has = true;
				s.LastStationDist = Dist(s.X, s.Z, petX, petZ);
				s.Stalls = 0;
				s.Restations = 0;
				s.LastAt = now;
				s.LastWhy = "first";
				return true;
			}
			float num2 = Dist(petX, petZ, enemyX, enemyZ);
			bool flag = num2 > attackRange + t.FarMeters;
			bool num3 = InCorridor(enemyX, enemyZ, ownerX, ownerZ, petX, petZ, t.LineAngleDeg, num);
			bool num4 = num2 <= num + 0.5f;
			float num5 = Dist(enemyX, enemyZ, s.EnemyAtX, s.EnemyAtZ);
			bool flag2 = !num4 && num5 < t.RestationMeters;
			bool flag3 = Dist(petX, petZ, s.X, s.Z) <= t.ArriveMeters + 0.5f;
			bool flag4 = flag3 && num2 > attackRange + 0.5f;
			bool flag5 = num3 && !flag2;
			if (flag && t.EnemyFastMetersPerSecond > 0f && !float.IsNaN(enemySpeed) && enemySpeed > t.EnemyFastMetersPerSecond)
			{
				flag = false;
				flag4 = false;
				if (!flag5 && now - s.LastAt >= t.RestationSeconds && now - s.LastFastHoldAt >= t.RestationSeconds)
				{
					s.FastHolds++;
					s.LastFastHoldAt = now;
				}
			}
			if (!flag && !flag4 && !flag5)
			{
				return false;
			}
			string text = (flag5 ? "corridor" : (flag ? "far" : "reach"));
			if (now - s.LastAt < t.RestationSeconds)
			{
				return false;
			}
			Ideal(enemyX, enemyZ, ownerX, ownerZ, petX, petZ, num, out var x, out var z);
			if (text == "far" && !flag3)
			{
				if (Dist(x, z, petX, petZ) > s.LastStationDist - t.ProgressMeters)
				{
					s.Stalls++;
					if (s.Stalls >= 2)
					{
						s.CapFallback = true;
						s.LastWhy = "stalled";
						s.LastAt = now;
						return false;
					}
				}
				else
				{
					s.Stalls = 0;
				}
			}
			if (Dist(x, z, petX, petZ) <= t.ArriveMeters || (!flag3 && Dist(x, z, s.X, s.Z) <= t.ArriveMeters))
			{
				s.LastAt = now;
				s.LastWhy = "near";
				return false;
			}
			bool flag6 = text != "reach";
			if (flag6 && s.Restations >= t.MaxRestations)
			{
				s.CapFallback = true;
				s.LastWhy = "cap";
				s.LastAt = now;
				return false;
			}
			s.X = x;
			s.Z = z;
			s.LastStationDist = Dist(x, z, petX, petZ);
			s.EnemyAtX = enemyX;
			s.EnemyAtZ = enemyZ;
			if (flag6)
			{
				s.Restations++;
			}
			else
			{
				s.Reaches++;
			}
			s.LastAt = now;
			s.LastWhy = text;
			return true;
		}

		public static void Reset(ref CombatStationState s)
		{
			s = default(CombatStationState);
		}

		public static float CorridorAngleDeg(float enemyX, float enemyZ, float ownerX, float ownerZ, float petX, float petZ)
		{
			float num = ownerX - enemyX;
			float num2 = ownerZ - enemyZ;
			float num3 = petX - enemyX;
			float num4 = petZ - enemyZ;
			float num5 = (float)Math.Sqrt(num * num + num2 * num2);
			float num6 = (float)Math.Sqrt(num3 * num3 + num4 * num4);
			if (num5 < 0.0001f || num6 < 0.0001f)
			{
				return 180f;
			}
			float num7 = (num * num3 + num2 * num4) / (num5 * num6);
			if (num7 > 1f)
			{
				num7 = 1f;
			}
			else if (num7 < -1f)
			{
				num7 = -1f;
			}
			return (float)(Math.Acos(num7) * 180.0 / Math.PI);
		}

		public static float CorridorBlockAngleDeg(float enemyX, float enemyZ, float ownerX, float ownerZ, float petX, float petZ)
		{
			float num = enemyX - ownerX;
			float num2 = enemyZ - ownerZ;
			float num3 = petX - ownerX;
			float num4 = petZ - ownerZ;
			float num5 = (float)Math.Sqrt(num * num + num2 * num2);
			float num6 = (float)Math.Sqrt(num3 * num3 + num4 * num4);
			if (num5 < 0.0001f || num6 < 0.0001f)
			{
				return 180f;
			}
			float num7 = (num * num3 + num2 * num4) / (num5 * num6);
			if (num7 > 1f)
			{
				num7 = 1f;
			}
			else if (num7 < -1f)
			{
				num7 = -1f;
			}
			return (float)(Math.Acos(num7) * 180.0 / Math.PI);
		}

		public static bool InCorridor(float enemyX, float enemyZ, float ownerX, float ownerZ, float petX, float petZ, float lineAngleDeg, float depthMeters)
		{
			if (CorridorBlockAngleDeg(enemyX, enemyZ, ownerX, ownerZ, petX, petZ) >= lineAngleDeg)
			{
				return false;
			}
			return Dist(ownerX, ownerZ, enemyX, enemyZ) - Dist(ownerX, ownerZ, petX, petZ) > depthMeters;
		}

		private static void Place(ref CombatStationState s, float ex, float ez, float ox, float oz, float px, float pz, float ring)
		{
			Ideal(ex, ez, ox, oz, px, pz, ring, out s.X, out s.Z);
			s.EnemyAtX = ex;
			s.EnemyAtZ = ez;
		}

		private static void Ideal(float ex, float ez, float ox, float oz, float px, float pz, float ring, out float x, out float z)
		{
			float num = ex - ox;
			float num2 = ez - oz;
			float num3 = (float)Math.Sqrt(num * num + num2 * num2);
			if (num3 < 0.0001f)
			{
				num = px - ex;
				num2 = pz - ez;
				num3 = (float)Math.Sqrt(num * num + num2 * num2);
				if (num3 < 0.0001f)
				{
					num = 1f;
					num2 = 0f;
					num3 = 1f;
				}
			}
			x = ex + num / num3 * ring;
			z = ez + num2 / num3 * ring;
		}

		private static float Dist(float ax, float az, float bx, float bz)
		{
			float num = ax - bx;
			float num2 = az - bz;
			return (float)Math.Sqrt(num * num + num2 * num2);
		}
	}
	public static class CombatSweep
	{
		public static bool ShouldDrop(bool alive, float distToPlayer, float combatLeash)
		{
			if (alive)
			{
				return distToPlayer > combatLeash;
			}
			return true;
		}
	}
	public enum CombatTargetSource
	{
		None,
		Commanded,
		OwnerFocus,
		AnchorDefend,
		PlayerEngaged
	}
	public struct CombatTargetFacts
	{
		public bool StancePassive;

		public bool CommandedExists;

		public float CommandedDistance;

		public bool AssistOnOwnerHit;

		public bool OwnerFocusExists;

		public float OwnerFocusDistance;

		public float OwnerFocusRange;

		public bool AnchorDefendExists;

		public bool AnchorDefendIsEcho;

		public float AnchorDefendDistance;

		public bool PlayerInCombat;

		public bool PlayerEngagedExists;

		public float PlayerEngagedDistance;

		public float AggroRange;

		public float CombatLeashDistance;
	}
	public struct CombatTargetDecision
	{
		public CombatTargetSource Source;

		public string Reason;

		public bool DropCommandedOrder;
	}
	public static class CombatTargetPolicy
	{
		private const string StaleReason = "beyond-combat-leash (stale, dropped)";

		public static CombatTargetDecision Decide(CombatTargetFacts f)
		{
			if (f.StancePassive)
			{
				return Clear("passive");
			}
			if (f.CommandedExists)
			{
				if (f.CommandedDistance > f.CombatLeashDistance)
				{
					return new CombatTargetDecision
					{
						Source = CombatTargetSource.None,
						Reason = "beyond-combat-leash (stale, dropped)",
						DropCommandedOrder = true
					};
				}
				return new CombatTargetDecision
				{
					Source = CombatTargetSource.Commanded,
					Reason = "commanded"
				};
			}
			if (f.AssistOnOwnerHit && f.OwnerFocusExists && f.OwnerFocusDistance <= f.OwnerFocusRange)
			{
				if (f.OwnerFocusDistance > f.CombatLeashDistance)
				{
					return Clear("beyond-combat-leash (stale, dropped)");
				}
				return new CombatTargetDecision
				{
					Source = CombatTargetSource.OwnerFocus,
					Reason = "owner-focus"
				};
			}
			if (f.AnchorDefendExists && !f.AnchorDefendIsEcho && f.AnchorDefendDistance <= f.AggroRange)
			{
				if (f.AnchorDefendDistance > f.CombatLeashDistance)
				{
					return Clear("beyond-combat-leash (stale, dropped)");
				}
				return new CombatTargetDecision
				{
					Source = CombatTargetSource.AnchorDefend,
					Reason = "anchor-defend"
				};
			}
			if (!f.PlayerInCombat)
			{
				return Clear("player-not-in-combat");
			}
			if (f.PlayerEngagedExists && f.PlayerEngagedDistance <= f.AggroRange)
			{
				if (f.PlayerEngagedDistance > f.CombatLeashDistance)
				{
					return Clear("beyond-combat-leash (stale, dropped)");
				}
				return new CombatTargetDecision
				{
					Source = CombatTargetSource.PlayerEngaged,
					Reason = "player-engaged"
				};
			}
			return Clear("none-in-aggro-range");
		}

		private static CombatTargetDecision Clear(string reason)
		{
			return new CombatTargetDecision
			{
				Source = CombatTargetSource.None,
				Reason = reason
			};
		}
	}
	public enum CommandMode
	{
		Engaged,
		Follow,
		Stay
	}
	public static class CommandCycle
	{
		public static CommandMode Next(CommandMode current)
		{
			return current switch
			{
				CommandMode.Engaged => CommandMode.Follow, 
				CommandMode.Follow => CommandMode.Stay, 
				_ => CommandMode.Engaged, 
			};
		}
	}
	public struct EquipState
	{
		public int ItemId;

		public float Durability;

		public float MaxDurability;

		public bool IsBroken => Durability <= 0f;

		public float Ratio
		{
			get
			{
				if (!(MaxDurability > 0f))
				{
					return 1f;
				}
				return Clamp01(Durability / MaxDurability);
			}
		}

		public static float Clamp01(float v)
		{
			if (!(v < 0f))
			{
				if (!(v > 1f))
				{
					return v;
				}
				return 1f;
			}
			return 0f;
		}
	}
	public static class EquipCodec
	{
		public static string Pack(string key, EquipState s, Action<string> warn = null)
		{
			if (s.ItemId == 0)
			{
				return "";
			}
			string text = (key ?? "").Trim();
			bool flag = text.Length == 0 || text.IndexOf(':') >= 0;
			if (!flag)
			{
				string text2 = text;
				for (int i = 0; i < text2.Length; i++)
				{
					if (char.IsControl(text2[i]))
					{
						flag = true;
						break;
					}
				}
			}
			if (flag)
			{
				warn?.Invoke("equipment key '" + key + "' is empty or carries ':'/control characters — stored as 'item'.");
				text = "item";
			}
			if (!Finite(s.Durability) || !Finite(s.MaxDurability))
			{
				warn?.Invoke($"equipment '{text}' has a non-finite durability ({s.Durability}/{s.MaxDurability}) — not persisted.");
				return "";
			}
			return text + ":" + s.ItemId.ToString(CultureInfo.InvariantCulture) + ":" + s.Durability.ToString("R", CultureInfo.InvariantCulture) + ":" + s.MaxDurability.ToString("R", CultureInfo.InvariantCulture);
		}

		public static bool TryParse(string cell, out string key, out EquipState state, Action<string> warn = null)
		{
			key = "";
			state = default(EquipState);
			if (string.IsNullOrEmpty(cell))
			{
				return false;
			}
			string[] array = cell.Split(new char[1] { ':' });
			if (array.Length != 4)
			{
				warn?.Invoke("malformed equipment cell '" + cell + "' (want key:itemId:dur:max) — read as nothing equipped.");
				return false;
			}
			if (!int.TryParse(array[1], NumberStyles.Integer, CultureInfo.InvariantCulture, out var result) || result <= 0)
			{
				warn?.Invoke("unreadable equipment item id '" + array[1] + "' — read as nothing equipped.");
				return false;
			}
			if (!TryFinite(array[2], out var v) || !TryFinite(array[3], out var v2) || v2 <= 0f)
			{
				warn?.Invoke("unreadable equipment durability '" + array[2] + "/" + array[3] + "' — read as nothing equipped.");
				return false;
			}
			if (v < 0f)
			{
				warn?.Invoke("negative equipment durability " + array[2] + " — clamped to 0 (broken).");
				v = 0f;
			}
			if (v > v2)
			{
				warn?.Invoke("equipment durability " + array[2] + " above max " + array[3] + " — clamped to max.");
				v = v2;
			}
			key = array[0];
			state = new EquipState
			{
				ItemId = result,
				Durability = v,
				MaxDurability = v2
			};
			return true;
		}

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

		private static bool TryFinite(string s, out float v)
		{
			if (float.TryParse(s, NumberStyles.Float, CultureInfo.InvariantCulture, out v))
			{
				return Finite(v);
			}
			return false;
		}
	}
	public struct WearPolicy
	{
		public float PerDamage;

		public float MinPerHit;

		public static WearPolicy Default => new WearPolicy
		{
			PerDamage = 0.05f,
			MinPerHit = 1f
		};
	}
	public static class EquipmentWear
	{
		public static float Loss(float preMitigationTotal, WearPolicy p)
		{
			if (preMitigationTotal <= 0f || float.IsNaN(preMitigationTotal))
			{
				return 0f;
			}
			float num = preMitigationTotal * ((p.PerDamage > 0f) ? p.PerDamage : 0f);
			if (p.MinPerHit > 0f && num < p.MinPerHit)
			{
				num = p.MinPerHit;
			}
			return num;
		}

		public static EquipState AfterHit(EquipState s, float preMitigationTotal, WearPolicy p)
		{
			if (s.ItemId == 0 || s.IsBroken)
			{
				return s;
			}
			float num = s.Durability - Loss(preMitigationTotal, p);
			s.Durability = ((num < 0f) ? 0f : num);
			return s;
		}
	}
	public struct ResistGrant
	{
		public float Phys;

		public float AllOther;

		public bool IsZero
		{
			get
			{
				if (Phys == 0f)
				{
					return AllOther == 0f;
				}
				return false;
			}
		}
	}
	public static class EquipmentEffects
	{
		public static void Apply(CreatureAttributes eff, ResistGrant grant, bool broken)
		{
			if (eff == null || broken || grant.IsZero)
			{
				return;
			}
			for (int i = 0; i < eff.Resist.Length; i++)
			{
				float num = ((i == 0) ? grant.Phys : grant.AllOther);
				if (num != 0f)
				{
					float num2 = eff.Resist[i] + num;
					eff.Resist[i] = ((num2 < -100f) ? (-100f) : ((num2 > 100f) ? 100f : num2));
				}
			}
		}
	}
	public enum RepairVerdict
	{
		Ok,
		AlreadyFull,
		NoReagent,
		NothingEquipped
	}
	public static class EquipmentRepair
	{
		public static RepairVerdict Evaluate(EquipState s, int reagentHeld, int reagentCost)
		{
			if (s.ItemId == 0)
			{
				return RepairVerdict.NothingEquipped;
			}
			if (s.Durability >= s.MaxDurability)
			{
				return RepairVerdict.AlreadyFull;
			}
			if (reagentHeld < reagentCost)
			{
				return RepairVerdict.NoReagent;
			}
			return RepairVerdict.Ok;
		}

		public static EquipState Repaired(EquipState s)
		{
			s.Durability = s.MaxDurability;
			return s;
		}
	}
	public enum BodilessAnchorPolicy
	{
		DestroyAnchor,
		UpkeepAnchor
	}
	public static class BodilessAnchorRule
	{
		public enum Action
		{
			None,
			Destroy,
			Upkeep
		}

		public static Action Decide(BodilessAnchorPolicy policy, bool anchorExists)
		{
			if (policy == BodilessAnchorPolicy.UpkeepAnchor)
			{
				return Action.Upkeep;
			}
			if (!anchorExists)
			{
				return Action.None;
			}
			return Action.Destroy;
		}
	}
	public static class HostTag
	{
		public const int MaxLength = 4;

		public static string Derive(string guidOrName)
		{
			if (string.IsNullOrEmpty(guidOrName))
			{
				return null;
			}
			int num = guidOrName.LastIndexOf('.');
			string obj = ((num >= 0 && num < guidOrName.Length - 1) ? guidOrName.Substring(num + 1) : guidOrName);
			StringBuilder stringBuilder = new StringBuilder(4);
			string text = obj;
			foreach (char c in text)
			{
				if (char.IsLetterOrDigit(c))
				{
					stringBuilder.Append(char.ToUpperInvariant(c));
					if (stringBuilder.Length >= 4)
					{
						break;
					}
				}
			}
			if (stringBuilder.Length != 0)
			{
				return stringBuilder.ToString();
			}
			return null;
		}
	}
	public static class CompanionSceneMath
	{
		public static void SpotAhead(double px, double pz, double fx, double fz, double aheadMeters, out double x, out double z)
		{
			double num = Math.Sqrt(fx * fx + fz * fz);
			if (num < 1E-06)
			{
				x = px;
				z = pz;
			}
			else
			{
				x = px + fx / num * aheadMeters;
				z = pz + fz / num * aheadMeters;
			}
		}

		public static bool Arrived(double moverX, double moverZ, double spotX, double spotZ, double arriveDistance)
		{
			double num = moverX - spotX;
			double num2 = moverZ - spotZ;
			return num * num + num2 * num2 <= arriveDistance * arriveDistance;
		}
	}
	public static class ContaminationPolicy
	{
		public static int Total(int photonViews, int netControls, int characterAi, int charAiDisable)
		{
			return photonViews + netControls + characterAi + charAiDisable;
		}

		public static bool ShouldRebuild(int contamination)
		{
			return contamination > 0;
		}

		public static string Describe(int photonViews, int netControls, int characterAi, int charAiDisable, int characters)
		{
			return "pv=" + photonViews + " ncc=" + netControls + " charAI=" + characterAi + " caid=" + charAiDisable + " character=" + characters;
		}
	}
	public static class CoopCaptureNormalizer
	{
		public static float Divisor(bool isGuestInRoom, int playersInLobby, float[] maxHealthMultipliers)
		{
			if (!isGuestInRoom || playersInLobby < 2)
			{
				return 1f;
			}
			if (maxHealthMultipliers == null || maxHealthMultipliers.Length == 0)
			{
				return 1f;
			}
			int num = playersInLobby - 2;
			if (num > maxHealthMultipliers.Length - 1)
			{
				num = maxHealthMultipliers.Length - 1;
			}
			float num2 = maxHealthMultipliers[num];
			if (float.IsNaN(num2) || float.IsInfinity(num2) || num2 <= 0f)
			{
				return 1f;
			}
			return num2;
		}

		public static float Normalize(float capturedMaxHealth, float divisor)
		{
			if (!(divisor > 0f) || float.IsNaN(divisor) || float.IsInfinity(divisor))
			{
				return capturedMaxHealth;
			}
			return capturedMaxHealth / divisor;
		}
	}
	public sealed class CreatureAttributes
	{
		public const int TypeCount = 9;

		public float MaxHealth;

		public float MoveSpeed;

		public float Impact;

		public float ImpactResistance;

		public float Barrier;

		public float ProtectionAll;

		public float StatusResistance;

		public float[] Resist = new float[9];

		public float[] Protection = new float[9];

		public float[] Damage = new float[9];

		public float DamageTotal
		{
			get
			{
				float num = 0f;
				for (int i = 0; i < Damage.Length; i++)
				{
					num += Damage[i];
				}
				return num;
			}
		}

		public bool HasDamage => DamageTotal > 0f;

		public CreatureAttributes Clone()
		{
			CreatureAttributes creatureAttributes = new CreatureAttributes
			{
				MaxHealth = MaxHealth,
				MoveSpeed = MoveSpeed,
				Impact = Impact,
				ImpactResistance = ImpactResistance,
				Barrier = Barrier,
				ProtectionAll = ProtectionAll,
				StatusResistance = StatusResistance
			};
			Array.Copy(Resist, creatureAttributes.Resist, 9);
			Array.Copy(Protection, creatureAttributes.Protection, 9);
			Array.Copy(Damage, creatureAttributes.Damage, 9);
			return creatureAttributes;
		}

		public float[] DistributeTotal(float total)
		{
			return DistributeTotal(Damage, total, 9);
		}

		public static float[] DistributeTotal(float[]? profile, float total, int typeCount)
		{
			if (typeCount < 1)
			{
				typeCount = 1;
			}
			float[] array = new float[typeCount];
			int num = ((profile != null) ? Math.Min(typeCount, profile.Length) : 0);
			float num2 = 0f;
			for (int i = 0; i < num; i++)
			{
				if (profile[i] > 0f)
				{
					num2 += profile[i];
				}
			}
			if (num2 <= 0f)
			{
				array[0] = total;
				return array;
			}
			float num3 = total / num2;
			for (int j = 0; j < num; j++)
			{
				if (profile[j] > 0f)
				{
					array[j] = profile[j] * num3;
				}
			}
			return array;
		}

		public string Flatten()
		{
			return Flatten(null);
		}

		public string Flatten(Action<string> warn)
		{
			StringBuilder stringBuilder = new StringBuilder();
			Scalar(stringBuilder, "hp", MaxHealth, warn);
			Scalar(stringBuilder, "spd", MoveSpeed, warn);
			Scalar(stringBuilder, "imp", Impact, warn);
			Scalar(stringBuilder, "impres", ImpactResistance, warn);
			Scalar(stringBuilder, "bar", Barrier, warn);
			Scalar(stringBuilder, "protall", ProtectionAll, warn);
			Scalar(stringBuilder, "statres", StatusResistance, warn);
			Sparse(stringBuilder, "res", Resist, warn);
			Sparse(stringBuilder, "prot", Protection, warn);
			Sparse(stringBuilder, "dmg", Damage, warn);
			return stringBuilder.ToString();
		}

		public static CreatureAttributes Parse(string s)
		{
			return Parse(s, null);
		}

		public static CreatureAttributes Parse(string s, Action<string> warn)
		{
			if (string.IsNullOrWhiteSpace(s))
			{
				return null;
			}
			CreatureAttributes creatureAttributes = new CreatureAttributes();
			bool flag = false;
			string[] array = s.Split(new char[1] { ';' });
			foreach (string text in array)
			{
				if (text.Trim().Length == 0)
				{
					continue;
				}
				int num = text.IndexOf('=');
				if (num <= 0)
				{
					warn?.Invoke("attributes: unreadable segment '" + text + "' (expected key=value) — skipped.");
					continue;
				}
				string text2 = text.Substring(0, num).Trim();
				string text3 = text.Substring(num + 1).Trim();
				switch (text2)
				{
				case "hp":
					flag |= TryF(text3, ref creatureAttributes.MaxHealth, warn, text2);
					break;
				case "spd":
					flag |= TryF(text3, ref creatureAttributes.MoveSpeed, warn, text2);
					break;
				case "imp":
					flag |= TryF(text3, ref creatureAttributes.Impact, warn, text2);
					break;
				case "impres":
					flag |= TryF(text3, ref creatureAttributes.ImpactResistance, warn, text2);
					break;
				case "bar":
					flag |= TryF(text3, ref creatureAttributes.Barrier, warn, text2);
					break;
				case "protall":
					flag |= TryF(text3, ref creatureAttributes.ProtectionAll, warn, text2);
					break;
				case "statres":
					flag |= TryF(text3, ref creatureAttributes.StatusResistance, warn, text2);
					break;
				case "res":
					flag |= ParseSparse(text3, creatureAttributes.Resist, warn, text2);
					break;
				case "prot":
					flag |= ParseSparse(text3, creatureAttributes.Protection, warn, text2);
					break;
				case "dmg":
					flag |= ParseSparse(text3, creatureAttributes.Damage, warn, text2);
					break;
				default:
					warn?.Invoke("attributes: unknown key '" + text2 + "' — ignored.");
					break;
				}
			}
			if (!flag)
			{
				warn?.Invoke("attributes: nothing readable in '" + s + "' — no capture restored.");
			}
			if (!flag)
			{
				return null;
			}
			return creatureAttributes;
		}

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

		private static void Scalar(StringBuilder sb, string key, float v, Action<string> warn)
		{
			if (v == 0f)
			{
				return;
			}
			if (!IsFinite(v))
			{
				warn?.Invoke($"attributes: non-finite '{key}' ({v}) — omitted.");
				return;
			}
			if (sb.Length > 0)
			{
				sb.Append(';');
			}
			sb.Append(key).Append('=').Append(v.ToString("R", CultureInfo.InvariantCulture));
		}

		private static void Sparse(StringBuilder sb, string key, float[] values, Action<string> warn)
		{
			bool flag = false;
			for (int i = 0; i < values.Length; i++)
			{
				if (values[i] == 0f)
				{
					continue;
				}
				if (!IsFinite(values[i]))
				{
					warn?.Invoke($"attributes: non-finite '{key}[{i}]' ({values[i]}) — omitted.");
					continue;
				}
				if (!flag)
				{
					if (sb.Length > 0)
					{
						sb.Append(';');
					}
					sb.Append(key).Append('=');
					flag = true;
				}
				else
				{
					sb.Append(',');
				}
				sb.Append(i.ToString(CultureInfo.InvariantCulture)).Append(':').Append(values[i].ToString("R", CultureInfo.InvariantCulture));
			}
		}

		private static bool ParseSparse(string list, float[] into, Action<string> warn, string key)
		{
			bool result = false;
			string[] array = list.Split(new char[1] { ',' });
			foreach (string text in array)
			{
				if (text.Trim().Length == 0)
				{
					continue;
				}
				int num = text.IndexOf(':');
				int result2;
				if (num <= 0)
				{
					warn?.Invoke("attributes: unreadable '" + key + "' entry '" + text + "' (expected index:value) — skipped.");
				}
				else if (!int.TryParse(text.Substring(0, num), NumberStyles.Integer, CultureInfo.InvariantCulture, out result2))
				{
					warn?.Invoke("attributes: unreadable '" + key + "' index '" + text.Substring(0, num) + "' — skipped.");
				}
				else if (result2 < 0 || result2 >= into.Length)
				{
					warn?.Invoke($"attributes: '{key}' index {result2} out of range (0..{into.Length - 1}) — skipped.");
				}
				else
				{
					float v = into[result2];
					if (TryF(text.Substring(num + 1), ref v, warn, $"{key}[{result2}]"))
					{
						into[result2] = v;
						result = true;
					}
				}
			}
			return result;
		}

		private static bool TryF(string s, ref float v, Action<string> warn, string field)
		{
			if (!float.TryParse(s, NumberStyles.Float, CultureInfo.InvariantCulture, out var result))
			{
				warn?.Invoke("attributes: unreadable '" + field + "' value '" + s + "' — skipped.");
				return false;
			}
			if (!IsFinite(result))
			{
				warn?.Invoke("attributes: non-finite '" + field + "' value '" + s + "' — skipped.");
				return false;
			}
			v = result;
			return true;
		}
	}
	public static class DamageRider
	{
		public static float Amount(float total, float fraction)
		{
			if (!(fraction > 0f) || !(total > 0f))
			{
				return 0f;
			}
			return total * fraction;
		}
	}
	public static class DisplayChainRisk
	{
		private static readonly string[] Tokens = new string[4] { "waterpro", "waterreflection", "waterrender", "aquas" };

		public static bool IsWaterReflectionRigName(string name)
		{
			if (string.IsNullOrEmpty(name))
			{
				return false;
			}
			for (int i = 0; i < Tokens.Length; i++)
			{
				if (name.IndexOf(Tokens[i], StringComparison.OrdinalIgnoreCase) >= 0)
				{
					return true;
				}
			}
			return false;
		}
	}
	public enum DonorMatch
	{
		None,
		Substring,
		Exact
	}
	public struct DonorChainPick
	{
		public int UsedIndex;

		public bool Revisit;

		public DonorChainPick(int usedIndex, bool revisit)
		{
			UsedIndex = usedIndex;
			Revisit = revisit;
		}
	}
	public static class DonorChain
	{
		public static bool AcceptSubstringAt(int chainIndex, int chainCount, bool haveEarlierFallback)
		{
			if (chainIndex >= chainCount - 1)
			{
				return !haveEarlierFallback;
			}
			return false;
		}

		public static DonorChainPick Resolve(IReadOnlyList<DonorMatch> probes)
		{
			int num = probes?.Count ?? 0;
			int num2 = -1;
			for (int i = 0; i < num; i++)
			{
				switch (probes[i])
				{
				case DonorMatch.Exact:
					return new DonorChainPick(i, revisit: false);
				case DonorMatch.Substring:
					if (AcceptSubstringAt(i, num, num2 >= 0))
					{
						return new DonorChainPick(i, revisit: false);
					}
					if (num2 < 0)
					{
						num2 = i;
					}
					break;
				}
			}
			if (num2 < 0)
			{
				return new DonorChainPick(-1, revisit: false);
			}
			return new DonorChainPick(num2, revisit: true);
		}
	}
	public static class DonorTable
	{
		private static readonly string[] OversizedSceneNames = new string[14]
		{
			"ChersoneseNewTerrain", "Emercar", "HallowedMarshNewTerrain", "Abrassar", "AntiqueField", "Caldera", "CierzoNewTerrain", "Berg", "Monsoon", "Levant",
			"Harmattan", "NewSirocco", "CierzoDestroyed", "CierzoTutorial"
		};

		public static IReadOnlyList<string> OversizedScenes => OversizedSceneNames;

		public static Dictionary<string, List<string>> Parse(string text)
		{
			Dictionary<string, List<string>> dictionary = new Dictionary<string, List<string>>(StringComparer.OrdinalIgnoreCase);
			foreach (SpeciesTable.TableLine item in SpeciesTable.Lines(text))
			{
				SplitPin(item.Key, out string key, out string _);
				if (key.Length == 0)
				{
					continue;
				}
				if (!dictionary.TryGetValue(key, out var value))
				{
					value = (dictionary[key] = new List<string>());
				}
				string[] fields = item.Fields;
				for (int i = 0; i < fields.Length; i++)
				{
					string text2 = fields[i].Trim();
					if (text2.Length != 0 && !value.Contains(text2, StringComparer.OrdinalIgnoreCase))
					{
						value.Add(text2);
					}
				}
			}
			return dictionary;
		}

		public static Dictionary<string, string> ParsePins(string text)
		{
			Dictionary<string, string> dictionary = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
			foreach (SpeciesTable.TableLine item in SpeciesTable.Lines(text))
			{
				SplitPin(item.Key, out string key, out string pin);
				if (key.Length != 0 && pin.Length != 0 && !dictionary.ContainsKey(key))
				{
					dictionary[key] = pin;
				}
			}
			return dictionary;
		}

		public static Dictionary<string, string> MergePins(Dictionary<string, string> builtIn, Dictionary<string, string> overrides)
		{
			Dictionary<string, string> dictionary = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
			if (builtIn != null)
			{
				foreach (KeyValuePair<string, string> item in builtIn)
				{
					dictionary[item.Key] = item.Value;
				}
			}
			if (overrides != null)
			{
				foreach (KeyValuePair<string, string> @override in overrides)
				{
					dictionary[@override.Key] = @override.Value;
				}
			}
			return dictionary;
		}

		private static void SplitPin(string rawKey, out string key, out string pin)
		{
			key = (rawKey ?? "").Trim();
			pin = "";
			int num = key.IndexOf('|');
			if (num >= 0)
			{
				pin = key.Substring(num + 1).Trim();
				key = key.Substring(0, num).Trim();
			}
		}

		public static bool PinMatches(string gameObjectName, string pin)
		{
			if (string.IsNullOrEmpty(gameObjectName) || string.IsNullOrEmpty(pin))
			{
				return false;
			}
			return string.Equals(StripInstanceSuffix(gameObjectName), StripInstanceSuffix(pin), StringComparison.OrdinalIgnoreCase);
		}

		public static string StripInstanceSuffix(string name)
		{
			string text = (name ?? "").Trim();
			bool flag = true;
			while (flag)
			{
				flag = false;
				if (text.EndsWith("(Clone)", StringComparison.OrdinalIgnoreCase))
				{
					text = text.Substring(0, text.Length - "(Clone)".Length).Trim();
					flag = true;
					continue;
				}
				if (!text.EndsWith(")", StringComparison.Ordinal))
				{
					break;
				}
				int num = text.LastIndexOf('(');
				if (num <= 0)
				{
					break;
				}
				bool flag2 = num + 1 < text.Length - 1;
				for (int i = num + 1; i < text.Length - 1 && flag2; i++)
				{
					if (!char.IsDigit(text[i]))
					{
						flag2 = false;
					}
				}
				if (!flag2)
				{
					break;
				}
				text = text.Substring(0, num).Trim();
				flag = true;
			}
			return text;
		}

		public static Dictionary<string, List<string>> Merge(Dictionary<string, List<string>> builtIn, Dictionary<string, List<string>> overrides)
		{
			Dictionary<string, List<string>> dictionary = new Dictionary<string, List<string>>(StringComparer.OrdinalIgnoreCase);
			if (overrides != null)
			{
				foreach (KeyValuePair<string, List<string>> @override in overrides)
				{
					dictionary[@override.Key] = new List<string>(@override.Value);
				}
			}
			if (builtIn != null)
			{
				foreach (KeyValuePair<string, List<string>> item in builtIn)
				{
					if (!dictionary.TryGetValue(item.Key, out var value))
					{
						value = (dictionary[item.Key] = new List<string>());
					}
					foreach (string item2 in item.Value)
					{
						if (!value.Contains(item2, StringComparer.OrdinalIgnoreCase))
						{
							value.Add(item2);
						}
					}
				}
			}
			return dictionary;
		}

		public static bool IsOversized(string sceneName)
		{
			if (string.IsNullOrEmpty(sceneName))
			{
				return false;
			}
			string[] oversizedSceneNames = OversizedSceneNames;
			for (int i = 0; i < oversizedSceneNames.Length; i++)
			{
				if (string.Equals(oversizedSceneNames[i], sceneName, StringComparison.OrdinalIgnoreCase))
				{
					return true;
				}
			}
			return false;
		}

		public static List<string> FilterViable(IEnumerable<string> scenes, out List<string> excluded)
		{
			List<string> list = new List<string>();
			excluded = new List<string>();
			foreach (string item in scenes ?? new List<string>())
			{
				(IsOversized(item) ? excluded : list).Add(item);
			}
			return list;
		}

		public static List<string> ExpeditionCandidates(IEnumerable<string> scenes)
		{
			FilterViable(scenes, out List<string> excluded);
			return excluded;
		}

		public static List<string> KeysForScene(Dictionary<string, List<string>> table, string sceneName)
		{
			return KeysForScene(table, sceneName, includeOversized: false);
		}

		public static List<string> KeysForScene(Dictionary<string, List<string>> table, string sceneName, bool includeOversized)
		{
			List<string> list = new List<string>();
			if (table == null || string.IsNullOrEmpty(sceneName))
			{
				return list;
			}
			foreach (KeyValuePair<string, List<string>> item in table)
			{
				if (item.Value == null)
				{
					continue;
				}
				foreach (string item2 in item.Value)
				{
					if ((includeOversized || !IsOversized(item2)) && string.Equals(item2, sceneName, StringComparison.OrdinalIgnoreCase))
					{
						list.Add(item.Key);
						break;
					}
				}
			}
			return list;
		}

		public static List<string> OrderCandidates(IEnumerable<string> scenes, string currentScene)
		{
			List<string> list = new List<string>();
			List<string> list2 = new List<string>();
			List<string> list3 = new List<string>();
			string text = Regions.RegionOf(currentScene);
			foreach (string item in scenes ?? new List<string>())
			{
				if (string.Equals(item, currentScene, StringComparison.OrdinalIgnoreCase))
				{
					list3.Add(item);
				}
				else if (text != null && Regions.RegionOf(item) == text)
				{
					list2.Add(item);
				}
				else
				{
					list.Add(item);
				}
			}
			list.AddRange(list2);
			list.AddRange(list3);
			return list;
		}

		private static bool Contains(this List<string> list, string value, StringComparer cmp)
		{
			foreach (string item in list)
			{
				if (cmp.Equals(item, value))
				{
					return true;
				}
			}
			return false;
		}
	}
	public static class Regions
	{
		private static readonly string[,] Keywords = new string[12, 2]
		{
			{ "Chersonese", "Chersonese" },
			{ "Cierzo", "Chersonese" },
			{ "Emercar", "Emercar" },
			{ "Berg", "Emercar" },
			{ "Hallowed", "Hallowed" },
			{ "Monsoon", "Hallowed" },
			{ "Abrassar", "Abrassar" },
			{ "Levant", "Abrassar" },
			{ "Antique", "Antique" },
			{ "Harmattan", "Antique" },
			{ "Caldera", "Caldera" },
			{ "Sirocco", "Caldera" }
		};

		public static string? RegionOf(string? sceneName)
		{
			if (sceneName == null || sceneName.Length == 0)
			{
				return null;
			}
			for (int i = 0; i < Keywords.GetLength(0); i++)
			{
				if (sceneName.IndexOf(Keywords[i, 0], StringComparison.OrdinalIgnoreCase) >= 0)
				{
					return Keywords[i, 1];
				}
			}
			return null;
		}
	}
	public static class SpeciesFloats
	{
		public static List<KeyValuePair<string, float>> Parse(string spec)
		{
			List<KeyValuePair<string, float>> list = new List<KeyValuePair<string, float>>();
			foreach (SpeciesTable.TableLine item in SpeciesTable.Lines(spec, ','))
			{
				float num = SpeciesTable.FloatOr(item.Fields, 0, float.NaN, null, item.Key);
				if (!float.IsNaN(num))
				{
					list.Add(new KeyValuePair<string, float>(item.Key, num));
				}
			}
			return list;
		}

		public static float For(List<KeyValuePair<string, float>> pairs, string speciesId)
		{
			string matchedKey;
			return ForKeyed(pairs, speciesId, out matchedKey);
		}

		public static float ForKeyed(List<KeyValuePair<string, float>> pairs, string speciesId, out string matchedKey)
		{
			matchedKey = null;
			if (pairs == null || string.IsNullOrEmpty(speciesId))
			{
				return float.NaN;
			}
			string text = null;
			float result = float.NaN;
			foreach (KeyValuePair<string, float> pair in pairs)
			{
				if (!string.IsNullOrEmpty(pair.Key))
				{
					if (string.Equals(pair.Key, speciesId, StringComparison.OrdinalIgnoreCase))
					{
						matchedKey = pair.Key;
						return pair.Value;
					}
					if (Species.NameMatches(speciesId, pair.Key) && (text == null || pair.Key.Length > text.Length))
					{
						text = pair.Key;
						result = pair.Value;
					}
				}
			}
			matchedKey = text;
			return result;
		}

		public static List<KeyValuePair<string, float>> Merge(List<KeyValuePair<string, float>> baseList, List<KeyValuePair<string, float>> overrides)
		{
			List<KeyValuePair<string, float>> list = new List<KeyValuePair<string, float>>();
			HashSet<string> hashSet = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
			if (overrides != null)
			{
				foreach (KeyValuePair<string, float> @override in overrides)
				{
					if (!string.IsNullOrEmpty(@override.Key))
					{
						hashSet.Add(@override.Key);
					}
				}
			}
			if (baseList != null)
			{
				foreach (KeyValuePair<string, float> @base in baseList)
				{
					if (string.IsNullOrEmpty(@base.Key) || !hashSet.Contains(@base.Key))
					{
						list.Add(@base);
					}
				}
			}
			if (overrides != null)
			{
				list.AddRange(overrides);
			}
			return list;
		}

		public static float ForLayered(List<KeyValuePair<string, float>> baseList, List<KeyValuePair<string, float>> overrides, string speciesId, out string matchedKey)
		{
			float num = ForKeyed(overrides, speciesId, out matchedKey);
			if (!float.IsNaN(num))
			{
				return num;
			}
			return ForKeyed(baseList, speciesId, out matchedKey);
		}
	}
	public static class SpeciesYaw
	{
		public static List<KeyValuePair<string, float>> Parse(string spec)
		{
			return SpeciesFloats.Parse(spec);
		}

		public static float For(List<KeyValuePair<string, float>> pairs, string speciesId)
		{
			return SpeciesFloats.For(pairs, speciesId);
		}

		public static Dictionary<string, float> ParseTable(string text, Action<string> warn = null)
		{
			Dictionary<string, float> dictionary = new Dictionary<string, float>(StringComparer.OrdinalIgnoreCase);
			foreach (SpeciesTable.TableLine item in SpeciesTable.Lines(text))
			{
				float num = SpeciesTable.FloatOr(item.Fields, 0, float.NaN, warn, item.Key);
				if (!float.IsNaN(num))
				{
					dictionary[item.Key] = num;
				}
			}
			return dictionary;
		}

		public static float Resolve(List<KeyValuePair<string, float>> embeddedPairs, List<KeyValuePair<string, float>> cfgPairs, IReadOnlyDictionary<string, float> sessionExact, string speciesId)
		{
			if (!string.IsNullOrEmpty(speciesId) && sessionExact != null && sessionExact.TryGetValue(speciesId, out var value))
			{
				return value;
			}
			return SpeciesFloats.For(SpeciesFloats.Merge(embeddedPairs, cfgPairs), speciesId);
		}
	}
	public static class SpeciesSlope
	{
		public static Dictionary<string, float> ParseTable(string text, Action<string> warn = null)
		{
			Dictionary<string, float> dictionary = new Dictionary<string, float>(StringComparer.OrdinalIgnoreCase);
			foreach (SpeciesTable.TableLine item in SpeciesTable.Lines(text))
			{
				float num = BoolField(item.Fields, warn, item.Key);
				if (!float.IsNaN(num))
				{
					dictionary[item.Key] = num;
				}
			}
			return dictionary;
		}

		public static float BoolField(string[] fields, Action<string> warn, string key)
		{
			return BoolField(fields, warn, key, "slope-tilt");
		}

		public static float BoolField(string[] fields, Action<string> warn, string key, string what)
		{
			if (fields == null || fields.Length == 0)
			{
				return float.NaN;
			}
			string text = fields[0].Trim();
			if (text.Length == 0)
			{
				return float.NaN;
			}
			if (text.Equals("true", StringComparison.OrdinalIgnoreCase) || text == "1")
			{
				return 1f;
			}
			if (text.Equals("false", StringComparison.OrdinalIgnoreCase) || text == "0")
			{
				return 0f;
			}
			warn?.Invoke("'" + key + "': unparsable " + what + " flag '" + text + "' (want true/false/1/0) — row skipped.");
			return float.NaN;
		}

		public static float Resolve(List<KeyValuePair<string, float>> pairs, string speciesId)
		{
			return SpeciesFloats.For(pairs, speciesId);
		}
	}
	public static class SpeciesBackpedal
	{
		public static Dictionary<string, float> ParseTable(string text, Action<string> warn = null)
		{
			Dictionary<string, float> dictionary = new Dictionary<string, float>(StringComparer.OrdinalIgnoreCase);
			foreach (SpeciesTable.TableLine item in SpeciesTable.Lines(text))
			{
				float num = SpeciesSlope.BoolField(item.Fields, warn, item.Key, "backpedal");
				if (!float.IsNaN(num))
				{
					dictionary[item.Key] = num;
				}
			}
			return dictionary;
		}

		public static float Resolve(List<KeyValuePair<string, float>> pairs, string speciesId)
		{
			return SpeciesFloats.For(pairs, speciesId);
		}
	}
	public static class DuplicateViewPolicy
	{
		public const int SceneBakedMax = 999;

		public static bool ShouldVeto(int viewId, bool oldAlive, string oldScene, string newScene, string activeScene)
		{
			if (!oldAlive)
			{
				return false;
			}
			if (viewId < 1 || viewId > 999)
			{
				return false;
			}
			if (string.IsNullOrEmpty(activeScene) || oldScene != activeScene)
			{
				return false;
			}
			return newScene != activeScene;
		}
	}
	public struct EffigyHarvestFacts
	{
		public bool Enabled;

		public bool ExpeditionBusy;

		public bool HarvestBusy;

		public bool HasAdditiveDonor;

		public bool HasExpeditionDonor;
	}
	public enum EffigyHarvestStep
	{
		Go,
		Disabled,
		NoDonor,
		ExpeditionOnly,
		Backoff,
		ExpeditionBusy,
		HarvestBusy
	}
	public sealed class EffigyHarvestGate
	{
		public const float DefaultRetrySeconds = 600f;

		private readonly Dictionary<string, float> _nextAttemptAt = new Dictionary<string, float>(StringComparer.OrdinalIgnoreCase);

		private readonly Dictionary<string, int> _failures = new Dictionary<string, int>(StringComparer.OrdinalIgnoreCase);

		public float RetrySeconds { get; set; }

		public EffigyHarvestGate(float retrySeconds = 600f)
		{
			RetrySeconds = retrySeconds;
		}

		public EffigyHarvestStep Decide(string species, in EffigyHarvestFacts facts, float now)
		{
			if (string.IsNullOrEmpty(species))
			{
				return EffigyHarvestStep.NoDonor;
			}
			if (!facts.Enabled)
			{
				return EffigyHarvestStep.Disabled;
			}
			if (!facts.HasAdditiveDonor)
			{
				if (!facts.HasExpeditionDonor)
				{
					return EffigyHarvestStep.NoDonor;
				}
				return EffigyHarvestStep.ExpeditionOnly;
			}
			if (_nextAttemptAt.TryGetValue(species, out var value) && now < value)
			{
				return EffigyHarvestStep.Backoff;
			}
			if (facts.ExpeditionBusy)
			{
				return EffigyHarvestStep.ExpeditionBusy;
			}
			if (facts.HarvestBusy)
			{
				return EffigyHarvestStep.HarvestBusy;
			}
			_nextAttemptAt[species] = now + RetrySeconds;
			return EffigyHarvestStep.Go;
		}

		public void ReportResult(string species, bool success, float now)
		{
			if (!string.IsNullOrEmpty(species))
			{
				if (success)
				{
					_nextAttemptAt.Remove(species);
					_failures.Remove(species);
				}
				else
				{
					_nextAttemptAt[species] = now + RetrySeconds;
					_failures.TryGetValue(species, out var value);
					_failures[species] = value + 1;
				}
			}
		}

		public int Failures(string species)
		{
			if (string.IsNullOrEmpty(species) || !_failures.TryGetValue(species, out var value))
			{
				return 0;
			}
			return value;
		}

		public float SecondsUntilRetry(string species, float now)
		{
			if (string.IsNullOrEmpty(species) || !_nextAttemptAt.TryGetValue(species, out var value))
			{
				return 0f;
			}
			float num = value - now;
			if (!(num > 0f))
			{
				return 0f;
			}
			return num;
		}

		public void Reset()
		{
			_nextAttemptAt.Clear();
			_failures.Clear();
		}
	}
	public enum EffigyBodyRung
	{
		None,
		Real,
		Ghost
	}
	public enum EffigySetResult
	{
		Refused,
		Created,
		Updated,
		SpeciesChanged
	}
	public enum EffigyStep
	{
		None,
		Acquire,
		Upgrade,
		Despawn
	}
	public sealed class EffigyRow
	{
		internal float NextAttemptAt;

		internal float AnchorUnresolvedAt;

		public string OwnerUid { get; internal set; }

		public string Species { get; internal set; }

		public int Tier { get; internal set; }

		public string Extension { get; internal set; } = "";

		public bool StancePassive { get; internal set; }

		public bool AnchorResolved { get; internal set; }

		public EffigyBodyRung Body { get; internal set; }
	}
	public sealed class EffigyLedger
	{
		public const float DefaultAcquireRetrySeconds = 3f;

		public const float DefaultUpgradeCheckSeconds = 10f;

		public const float AnchorLossGraceSeconds = 8f;

		private readonly float _acquireRetrySeconds;

		private readonly float _upgradeCheckSeconds;

		private readonly Dictionary<string, EffigyRow> _rows = new Dictionary<string, EffigyRow>(StringComparer.Ordinal);

		public int Count => _rows.Count;

		public int LiveBodies
		{
			get
			{
				int num = 0;
				foreach (KeyValuePair<string, EffigyRow> row in _rows)
				{
					if (row.Value.Body != EffigyBodyRung.None)
					{
						num++;
					}
				}
				return num;
			}
		}

		public EffigyLedger(float acquireRetrySeconds = 3f, float upgradeCheckSeconds = 10f)
		{
			_acquireRetrySeconds = acquireRetrySeconds;
			_upgradeCheckSeconds = upgradeCheckSeconds;
		}

		public List<EffigyRow> RowsSnapshot()
		{
			List<EffigyRow> list = new List<EffigyRow>(_rows.Count);
			foreach (KeyValuePair<string, EffigyRow> row in _rows)
			{
				list.Add(row.Value);
			}
			return list;
		}

		public bool TryGet(string ownerUid, out EffigyRow row)
		{
			return _rows.TryGetValue(ownerUid ?? "", out row);
		}

		public EffigySetResult Set(string ownerUid, string species, int tier)
		{
			return Set(ownerUid, species, tier, "");
		}

		public EffigySetResult Set(string ownerUid, string species, int tier, string extension)
		{
			if (string.IsNullOrEmpty(ownerUid) || string.IsNullOrEmpty(species))
			{
				return EffigySetResult.Refused;
			}
			tier = NetProtocol.ClampTier(tier);
			extension = extension ?? "";
			if (!_rows.TryGetValue(ownerUid, out EffigyRow value))
			{
				_rows[ownerUid] = new EffigyRow
				{
					OwnerUid = ownerUid,
					Species = species,
					Tier = tier,
					Extension = extension
				};
				return EffigySetResult.Created;
			}
			bool num = !string.Equals(value.Species, species, StringComparison.Ordinal);
			value.Species = species;
			value.Tier = tier;
			value.Extension = extension;
			if (num)
			{
				value.NextAttemptAt = 0f;
			}
			if (!num)
			{
				return EffigySetResult.Updated;
			}
			return EffigySetResult.SpeciesChanged;
		}

		public bool SetStance(string ownerUid, bool passive)
		{
			if (!_rows.TryGetValue(ownerUid ?? "", out EffigyRow value) || value.StancePassive == passive)
			{
				return false;
			}
			value.StancePassive = passive;
			return true;
		}

		public bool Clear(string ownerUid)
		{
			return _rows.Remove(ownerUid ?? "");
		}

		public int ClearAll()
		{
			int count = _rows.Count;
			_rows.Clear();
			return count;
		}

		public void MarkAnchor(string ownerUid, bool resolved, float now)
		{
			if (_rows.TryGetValue(ownerUid ?? "", out EffigyRow value))
			{
				if (value.AnchorResolved && !resolved)
				{
					value.AnchorUnresolvedAt = now;
				}
				value.AnchorResolved = resolved;
			}
		}

		public void MarkBody(string ownerUid, EffigyBodyRung rung)
		{
			if (_rows.TryGetValue(ownerUid ?? "", out EffigyRow value))
			{
				value.Body = rung;
				if (rung == EffigyBodyRung.None)
				{
					value.NextAttemptAt = 0f;
				}
			}
		}

		public EffigyStep Reconcile(EffigyRow row, bool enabled, int maxBodies, float now)
		{
			if (row == null)
			{
				return EffigyStep.None;
			}
			if (!enabled)
			{
				if (row.Body == EffigyBodyRung.None)
				{
					return EffigyStep.None;
				}
				return EffigyStep.Despawn;
			}
			if (!row.AnchorResolved)
			{
				if (row.Body == EffigyBodyRung.None)
				{
					return EffigyStep.None;
				}
				if (!(now - row.AnchorUnresolvedAt >= 8f))
				{
					return EffigyStep.None;
				}
				return EffigyStep.Despawn;
			}
			switch (row.Body)
			{
			case EffigyBodyRung.None:
				if (LiveBodies >= maxBodies)
				{
					return EffigyStep.None;
				}
				if (now < row.NextAttemptAt)
				{
					return EffigyStep.None;
				}
				row.NextAttemptAt = now + _acquireRetrySeconds;
				return EffigyStep.Acquire;
			case EffigyBodyRung.Ghost:
				if (now < row.NextAttemptAt)
				{
					return EffigyStep.None;
				}
				row.NextAttemptAt = now + _upgradeCheckSeconds;
				return EffigyStep.Upgrade;
			default:
				return EffigyStep.None;
			}
		}
	}
	public static class EffigyPinMath
	{
		public enum PinMove
		{
			Weld,
			Glide,
			Snap
		}

		public readonly struct PinStep
		{
			public readonly PinMove Mode;

			public readonly float MaxStep;

			public readonly float Distance;

			public PinStep(PinMove mode, float maxStep, float distance)
			{
				Mode = mode;
				MaxStep = maxStep;
				Distance = distance;
			}
		}

		public const float MaxAnimForward = 8f;

		public const float MinFacingSqr = 0.0001f;

		public static bool HorizontalFacing(float fx, float fz, out float nx, out float nz)
		{
			float num = fx * fx + fz * fz;
			if (num < 0.0001f)
			{
				nx = 0f;
				nz = 0f;
				return false;
			}
			float num2 = 1f / (float)Math.Sqrt(num);
			nx = fx * num2;
			nz = fz * num2;
			return true;
		}

		public static float HorizontalSpeed(float dx, float dz, float dt)
		{
			if (dt <= 0.0001f)
			{
				return 0f;
			}
			return (float)Math.Sqrt((double)dx * (double)dx + (double)dz * (double)dz) / dt;
		}

		public static PinStep CatchUpStep(float distance, float deadBand, float catchUpSpeed, float snapDistance, float dt)
		{
			if (!(distance > 0f))
			{
				return new PinStep(PinMove.Weld, 0f, 0f);
			}
			if (snapDistance > 0f && distance >= snapDistance)
			{
				return new PinStep(PinMove.Snap, distance, distance);
			}
			if (distance <= deadBand)
			{
				return new PinStep(PinMove.Weld, 0f, distance);
			}
			float num = ((dt > 0f && catchUpSpeed > 0f) ? (catchUpSpeed * dt) : 0f);
			if (num > distance)
			{
				num = distance;
			}
			return new PinStep(PinMove.Glide, num, distance);
		}

		public static float AnimForward(float speed, bool moving)
		{
			if (!moving)
			{
				return 0f;
			}
			if (speed < 0f)
			{
				return 0f;
			}
			if (!(speed > 8f))
			{
				return speed;
			}
			return 8f;
		}
	}
	public static class ExpeditionConfigMigration
	{
		public enum Outcome
		{
			SkipLegacyDefault,
			SkipInSync,
			SkipCkCustomized,
			Migrate
		}

		public static Outcome Decide<T>(T legacy, T legacyDefault, T ck, T ckDefault)
		{
			EqualityComparer<T> equalityComparer = EqualityComparer<T>.Default;
			if (equalityComparer.Equals(legacy, legacyDefault))
			{
				return Outcome.SkipLegacyDefault;
			}
			if (equalityComparer.Equals(legacy, ck))
			{
				return Outcome.SkipInSync;
			}
			if (!equalityComparer.Equals(ck, ckDefault))
			{
				return Outcome.SkipCkCustomized;
			}
			return Outcome.Migrate;
		}
	}
	public static class ExpeditionCoop
	{
		public struct GuestGateState
		{
			public bool Enabled;

			public bool IsGuest;

			public bool HostExpeditionActive;

			public bool GateArmed;

			public bool ContinueAlreadySet;

			public bool GameplayLoading;

			public bool AllPlayersDone;

			public bool MasterLoadingDisplayed;
		}

		public static bool ShouldRefuseBegin(bool allowCoop, bool inRoom, int otherPlayerCount)
		{
			if (!allowCoop && inRoom)
			{
				return otherPlayerCount > 0;
			}
			return false;
		}

		public static bool ShouldGuestContinue(in GuestGateState s)
		{
			if (s.Enabled && s.IsGuest && s.HostExpeditionActive && s.GateArmed && !s.ContinueAlreadySet && !s.GameplayLoading && s.AllPlayersDone)
			{
				return s.MasterLoadingDisplayed;
			}
			return false;
		}
	}
	public static class ExpeditionLog
	{
		public static List<string> Parse(string text)
		{
			List<string> list = new List<string>();
			if (string.IsNullOrEmpty(text))
			{
				return list;
			}
			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] != '#')
				{
					Append(list, text2);
				}
			}
			return list;
		}

		public static string Format(IEnumerable<string> scenes)
		{
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.Append("# Scenes whose body templates have been dumped by an expedition or in-place capture.\n");
			stringBuilder.Append("# Read at boot for [Expedition] AutoWarmAtBoot=all; safe to edit or delete.\n");
			if (scenes != null)
			{
				foreach (string scene in scenes)
				{
					if (!string.IsNullOrEmpty(scene))
					{
						stringBuilder.Append(scene).Append('\n');
					}
				}
			}
			return stringBuilder.ToString();
		}

		public static bool Append(List<string> scenes, string scene)
		{
			if (scenes == null || string.IsNullOrEmpty(scene))
			{
				return false;
			}
			foreach (string scene2 in scenes)
			{
				if (string.Equals(scene2, scene, StringComparison.OrdinalIgnoreCase))
				{
					return false;
				}
			}
			scenes.Add(scene);
			return true;
		}
	}
	public static class ExpeditionWarm
	{
		public enum Mode
		{
			Off,
			Needed,
			All
		}

		public struct SpeciesResolve
		{
			public string Species;

			public bool HasExpeditionScenes;

			public string FirstExpeditionScene;

			public bool HasAdditiveDonor;

			public bool HasCachedTemplate;

			public bool DonorSceneVisited;
		}

		public enum ListOutcome
		{
			Warm,
			SkippedAdditive,
			SkippedCached,
			DeferredUnvisited,
			Unknown,
			SkippedActiveCompanion
		}

		public struct ListDecision
		{
			public string Species;

			public ListOutcome Outcome;

			public string Scene;
		}

		public sealed class PlanInput
		{
			public Mode Mode;

			public SpeciesResolve? ActivePet;

			public IEnumerable<string> ManifestScenes;

			public Func<string, bool> SceneHasUncachedKey;

			public List<SpeciesResolve> AlwaysWarm;

			public Func<string, bool> SceneVisited;
		}

		public sealed class Plan
		{
			public List<string> Scenes = new List<string>();

			public List<ListDecision> ListDecisions = new List<ListDecision>();

			public List<string> DeferredScenes = new List<string>();

			public bool AnyDeferred => DeferredScenes.Count > 0;
		}

		public struct StorySafety
		{
			public bool InPrologue;

			public bool CurrentSceneFirstLoad;
		}

		public struct WarmRetryPolicy
		{
			public float MaxWaitSeconds;

			public float PollSeconds;
		}

		public struct WarmRetryState
		{
			public float ElapsedSeconds;

			public int Polls;
		}

		public enum WarmGate
		{
			Proceed,
			Wait,
			GiveUp
		}

		public static bool TryParseMode(string raw, out Mode mode)
		{
			mode = Mode.Off;
			string a = raw?.Trim();
			if (string.Equals(a, "off", StringComparison.OrdinalIgnoreCase))
			{
				mode = Mode.Off;
				return true;
			}
			if (string.Equals(a, "needed", StringComparison.OrdinalIgnoreCase))
			{
				mode = Mode.Needed;
				return true;
			}
			if (string.Equals(a, "all", StringComparison.OrdinalIgnoreCase))
			{
				mode = Mode.All;
				return true;
			}
			return false;
		}

		public static List<string> ParseSpeciesList(string raw)
		{
			List<string> list = new List<string>();
			if (string.IsNullOrEmpty(raw))
			{
				return list;
			}
			string[] array = raw.Split(new char[1] { ',' });
			foreach (string text in array)
			{
				ExpeditionLog.Append(list, text.Trim());
			}
			return list;
		}

		public static bool StoryHold(in StorySafety s, out string reason)
		{
			if (s.InPrologue)
			{
				reason = "the prologue/tutorial is active";
				return true;
			}
			if (s.CurrentSceneFirstLoad)
			{
				reason = "the current scene is being visited for the FIRST time (departing would save it mid-story and consume its one-shot beats)";
				return true;
			}
			reason = null;
			return false;
		}

		public static string NeededScene(in SpeciesResolve r)
		{
			if (!r.HasExpeditionScenes || r.HasAdditiveDonor || r.HasCachedTemplate || !r.DonorSceneVisited || string.IsNullOrEmpty(r.FirstExpeditionScene))
			{
				return null;
			}
			return r.FirstExpeditionScene;
		}

		public static ListDecision DecideListed(in SpeciesResolve r)
		{
			ListDecision result = new ListDecision
			{
				Species = r.Species
			};
			if (!r.HasExpeditionScenes && !r.HasAdditiveDonor)
			{
				result.Outcome = ListOutcome.Unknown;
			}
			else if (r.HasAdditiveDonor)
			{
				result.Outcome = ListOutcome.SkippedAdditive;
			}
			else if (r.HasCachedTemplate)
			{
				result.Outcome = ListOutcome.SkippedCached;
			}
			else if (string.IsNullOrEmpty(r.FirstExpeditionScene))
			{
				result.Outcome = ListOutcome.Unknown;
			}
			else if (!r.DonorSceneVisited)
			{
				result.Outcome = ListOutcome.DeferredUnvisited;
				result.Scene = r.FirstExpeditionScene;
			}
			else
			{
				result.Outcome = ListOutcome.Warm;
				result.Scene = r.FirstExpeditionScene;
			}
			return result;
		}

		public static Plan Decide(PlanInput input)
		{
			Plan plan = new Plan();
			if (input == null)
			{
				return plan;
			}
			Func<string, bool> func = input.SceneVisited ?? ((Func<string, bool>)((string _) => true));
			switch (input.Mode)
			{
			case Mode.Needed:
			{
				if (!input.ActivePet.HasValue)
				{
					break;
				}
				SpeciesResolve r = input.ActivePet.Value;
				string text = NeededScene(in r);
				if (text != null)
				{
					ExpeditionLog.Append(plan.Scenes, text);
				}
				else if (!r.DonorSceneVisited)
				{
					string text2 = NeededSceneIgnoringVisited(in r);
					if (text2 != null)
					{
						ExpeditionLog.Append(plan.DeferredScenes, text2);
					}
				}
				break;
			}
			case Mode.All:
				if (input.ManifestScenes == null || input.SceneHasUncachedKey == null)
				{
					break;
				}
				foreach (string manifestScene in input.ManifestScenes)
				{
					if (!string.IsNullOrEmpty(manifestScene) && input.SceneHasUncachedKey(manifestScene))
					{
						if (func(manifestScene))
						{
							ExpeditionLog.Append(plan.Scenes, manifestScene);
						}
						else
						{
							ExpeditionLog.Append(plan.DeferredScenes, manifestScene);
						}
					}
				}
				break;
			}
			if (input.AlwaysWarm != null)
			{
				bool flag = !input.ActivePet.HasValue;
				if (!flag)
				{
					foreach (SpeciesResolve item2 in input.AlwaysWarm)
					{
						if (string.Equals(item2.Species, input.ActivePet.Value.Species, StringComparison.OrdinalIgnoreCase))
						{
							flag = true;
							break;
						}
					}
				}
				foreach (SpeciesResolve item3 in input.AlwaysWarm)
				{
					SpeciesResolve r2 = item3;
					if (!flag)
					{
						plan.ListDecisions.Add(new ListDecision
						{
							Species = r2.Species,
							Outcome = ListOutcome.SkippedActiveCompanion
						});
						continue;
					}
					ListDecision item = DecideListed(in r2);
					plan.ListDecisions.Add(item);
					if (item.Outcome == ListOutcome.Warm)
					{
						ExpeditionLog.Append(plan.Scenes, item.Scene);
					}
					else if (item.Outcome == ListOutcome.DeferredUnvisited)
					{
						ExpeditionLog.Append(plan.DeferredScenes, item.Scene);
					}
				}
			}
			for (int num = plan.DeferredScenes.Count - 1; num >= 0; num--)
			{
				foreach (string scene in plan.Scenes)
				{
					if (string.Equals(scene, plan.DeferredScenes[num], StringComparison.OrdinalIgnoreCase))
					{
						plan.DeferredScenes.RemoveAt(num);
						break;
					}
				}
			}
			return plan;
		}

		private static string NeededSceneIgnoringVisited(in SpeciesResolve r)
		{
			if (!r.HasExpeditionScenes || r.HasAdditiveDonor || r.HasCachedTemplate || string.IsNullOrEmpty(r.FirstExpeditionScene))
			{
				return null;
			}
			return r.FirstExpeditionScene;
		}

		public static WarmGate WarmRetryStep(in WarmRetryState s, bool blocked, in WarmRetryPolicy p)
		{
			if (!blocked)
			{
				return WarmGate.Proceed;
			}
			if (s.ElapsedSeconds >= p.MaxWaitSeconds)
			{
				return WarmGate.GiveUp;
			}
			return WarmGate.Wait;
		}

		public static WarmRetryState WarmRetryAdvance(in WarmRetryState s, float pollSeconds)
		{
			return new WarmRetryState
			{
				ElapsedSeconds = s.ElapsedSeconds + ((pollSeconds > 0f) ? pollSeconds : 0f),
				Polls = s.Polls + 1
			};
		}

		public static int WarmRetryTerminates(in WarmRetryPolicy p, int guardSteps = 100000)
		{
			WarmRetryState s = default(WarmRetryState);
			for (int i = 0; i < guardSteps; i++)
			{
				switch (WarmRetryStep(in s, blocked: true, in p))
				{
				case WarmGate.GiveUp:
					return i;
				default:
					return i;
				case WarmGate.Wait:
					break;
				}
				s = WarmRetryAdvance(in s, p.PollSeconds);
			}
			return -1;
		}
	}
	public static class ExpeditionResume
	{
		public enum Action
		{
			Ignore,
			RunPayloadThenReturn,
			Restore,
			AbortLoud
		}

		public struct State
		{
			public int Leg;

			public string ActiveScene;

			public string HomeScene;

			public string DonorScene;

			public bool ReturnRequested;

			public bool Restoring;

			public bool PayloadRan;

			public bool LoaderBusy;
		}

		public struct Decision
		{
			public Action Action;

			public string Reason;
		}

		public static Decision Decide(State s)
		{
			if (s.LoaderBusy)
			{
				return Make(Action.Ignore, "a load is still in flight (scene '" + s.ActiveScene + "') — not a landing");
			}
			bool flag = SameScene(s.ActiveScene, s.HomeScene);
			bool flag2 = SameScene(s.ActiveScene, s.DonorScene);
			if (s.Leg == 1)
			{
				if (flag2)
				{
					return Make(Action.RunPayloadThenReturn, s.PayloadRan ? "landed in the donor scene (payload already ran) — heading home" : "landed in the donor scene — running the payload, then heading home");
				}
				if (flag)
				{
					return Make(Action.Ignore, "still in the home scene on the outbound leg — the switch was already requested and is in motion; a resume cannot mean 'it never left' (the watchdog covers a dead outbound)");
				}
				return Make(Action.AbortLoud, "outbound landed in unexpected scene '" + s.ActiveScene + "'");
			}
			if (s.Leg == 2)
			{
				if (flag)
				{
					if (!s.Restoring)
					{
						return Make(Action.Restore, "landed home — restoring player position(s)");
					}
					return Make(Action.Ignore, "home, but a restore is already running — duplicate resume");
				}
				if (flag2)
				{
					return Make(Action.Ignore, s.ReturnRequested ? "still in the donor scene — the return was requested but its load has not landed yet" : "still in the donor scene — the return-leg dwell has not fired yet");
				}
				return Make(Action.AbortLoud, "return leg landed in unexpected scene '" + s.ActiveScene + "'");
			}
			return Make(Action.Ignore, $"no leg in flight (leg {s.Leg})");
		}

		private static Decision Make(Action a, string why)
		{
			return new Decision
			{
				Action = a,
				Reason = why
			};
		}

		private static bool SameScene(string a, string b)
		{
			if (!string.IsNullOrEmpty(a) && !string.IsNullOrEmpty(b))
			{
				return string.Equals(a, b, StringComparison.OrdinalIgnoreCase);
			}
			return false;
		}
	}
	public static class ExpeditionVerb
	{
		public enum Kind
		{
			Status,
			Delay,
			DelayInvalid,
			Target
		}

		public struct Command
		{
			public Kind Kind;

			public float DelaySeconds;

			public string Target;

			public bool Force;
		}

		public const float MaxDelaySeconds = 30f;

		public static Command Parse(string[] parts)
		{
			if (parts == null || parts.Length < 2)
			{
				return new Command
				{
					Kind = Kind.Status
				};
			}
			if (parts.Length >= 3 && string.Equals(parts[1], "delay", StringComparison.OrdinalIgnoreCase))
			{
				if (float.TryParse(parts[2], NumberStyles.Float, CultureInfo.InvariantCulture, out var result) && result >= 0f && result <= 30f)
				{
					return new Command
					{
						Kind = Kind.Delay,
						DelaySeconds = result
					};
				}
				return new Command
				{
					Kind = Kind.DelayInvalid
				};
			}
			if (parts.Length >= 3 && string.Equals(parts[1], "force", StringComparison.OrdinalIgnoreCase))
			{
				return new Command
				{
					Kind = Kind.Target,
					Force = true,
					Target = string.Join(" ", parts, 2, parts.Length - 2)
				};
			}
			return new Command
			{
				Kind = Kind.Target,
				Target = string.Join(" ", parts, 1, parts.Length - 1)
			};
		}
	}
	public static class FacingPolicy
	{
		public static bool ForceEnemyHeading(bool hasCombatTarget, bool planted)
		{
			if (hasCombatTarget)
			{
				return LookTargetPolicy.Choose(hasCombatTarget, planted, stationActive: true, pointingHold: false, loafActive: false, approachActive: false, settled: false) == LookTarget.Enemy;
			}
			return false;
		}

		public static bool FaceDriveDestination(bool loafActive, bool approachActive)
		{
			return LookTargetPolicy.Choose(hasCombat: false, planted: false, stationActive: false, pointingHold: false, loafActive, approachActive, settled: false) == LookTarget.Travel;
		}

		public static bool ForcePointHeading(bool pointingHold)
		{
			return LookTargetPolicy.Choose(hasCombat: false, planted: false, stationActive: false, pointingHold, loafActive: false, approachActive: false, settled: false) == LookTarget.FacePoint;
		}
	}
	public enum FollowMode
	{
		Hold,
		Direct,
		Replace,
		Agent
	}
	public enum HoldReason
	{
		None,
		NoTargetOrAgent,
		VoidStaging,
		AgentSuspended
	}
	public enum ReplaceDestination
	{
		Goal,
		Owner
	}
	public sealed class FollowTuning
	{
		public float ZoneReplaceDistance = 50f;

		public float ReplaceThrottleSeconds = 0.4f;

		public float LeashWarpThrottleSeconds = 0.75f;

		public float RoofSanityMeters = 1.5f;

		public float RepathIntervalSeconds = 0.2f;

		public float RepathHysteresisSq = 0.16f;

		public float GoalSampleRadius = 2f;

		public float OwnerSampleRadius = 2f;

		public float LoafSampleRadius = 2f;

		public float PlantHysteresisMeters = 1.5f;

		public float CantReachSlack = 2f;

		public float CantReachGraceSeconds = 1.5f;

		public float LeashWarpSearchRadius = 8f;

		public float LoafReengageGraceSeconds = 1.5f;

		public float LoafArriveDistance = 0.6f;

		public float CatchUpNearMeters = 5f;

		public float CatchUpRampMeters = 4f;

		public float FollowAngularSpeed = 240f;

		public float FollowAcceleration = 12f;

		public float BrakeWithinMeters = 2.5f;

		public float CombatAngularSpeed = 540f;

		public float CombatAcceleration = 40f;

		public float WarpBehindMeters = 12.5f;

		public float WarpBehindStepMeters = 5f;

		public float WarpBehindMaxMeters = 22.5f;

		public float WarpSideMeters = -0.5f;

		public float OffscreenMargin = 0.08f;

		public float ApproachFarMeters = 5f;

		public float ApproachArriveMeters = 0.9f;

		public float ApproachRefuseEnterMeters = 1.5f;

		public float ApproachRefuseExitMeters = 2f;

		public float TurnSpeed = 0.08f;

		public float StationArriveMeters = 0.8f;
	}
	public struct FollowFacts
	{
		public bool HasTargetAndAgent;

		public bool TargetSane;

		public bool AgentAbandoned;

		public float DistToOwner;

		public bool HasCombatTarget;

		public bool HasFollowOverride;

		public bool HasSceneSpot;

		public bool HasStaySpot;

		public bool GoalIsOwner;

		public bool GoalOnMesh;

		public bool AgentOnMesh;

		public bool AgentEnabled;

		public bool AgentSuspendedExternally;

		public float Now;

		public float LastReplaceAt;

		public float LeashGraceUntil;

		public float FaceUntil;

		public float BaseSpeed;

		public float FollowSpeedFloor;

		public float FollowRefDist;

		public float CatchUpSpeed;

		public float LeashDistance;

		public float CombatLeashDistance;

		public bool SuppressLeashWarp;
	}
	public struct FollowDecision
	{
		public FollowMode Mode;

		public HoldReason Hold;

		public bool PreReplaceOwner;

		public bool ReplaceNow;

		public ReplaceDestination ReplaceDest;

		public bool ReplaceMeasurable;

		public bool LoafEligible;

		public float DriveSpeed;
	}
	public struct AgentDriveFacts
	{
		public bool HasCombatTarget;

		public float GoalDist;

		public float AttackRange;

		public bool WasPlanted;

		public float Now;

		public float FaceUntil;

		public bool LoafActive;

		public bool ApproachActive;

		public bool SceneSpotActive;

		public bool StaySpotActive;

		public bool HasPath;

		public float LastRepathAt;

		public float DestMovedSq;

		public float LeashDist;

		public float LeashGraceUntil;

		public bool PathPending;

		public bool PathComplete;

		public float LastWarpAt;

		public float CantReachSince;

		public float StopDistance;

		public float LeashDistance;

		public float CombatLeashDistance;

		public bool SuppressLeashWarp;

		public bool HasStation;

		public float StationDist;

		public float StationArriveMeters;
	}
	public enum WarpReason
	{
		None,
		Leash,
		CantReach
	}
	public struct AgentDrivePlan
	{
		public bool Planted;

		public bool HoldForCombat;

		public bool PointingHold;

		public bool AgentStopped;

		public float StoppingDistance;

		public bool Repath;

		public bool GraceEnded;

		public bool LeashWarp;

		public WarpReason LeashWarpReason;

		public bool CantReachNow;

		public bool ClearWarpBlocked;
	}
	public static class FollowPolicy
	{
		public static bool NeedsGoalSample(in FollowFacts f)
		{
			if (f.HasTargetAndAgent && f.TargetSane)
			{
				return !f.AgentAbandoned;
			}
			return false;
		}

		public static bool ShouldReArmAgent(in FollowFacts f)
		{
			if (f.GoalOnMesh && !f.AgentEnabled)
			{
				return !f.AgentSuspendedExternally;
			}
			return false;
		}

		public static FollowDecision Decide(in FollowFacts f, FollowTuning t)
		{
			FollowDecision result = new FollowDecision
			{
				DriveSpeed = FollowSpeed(f.FollowRefDist, f.BaseSpeed, f.FollowSpeedFloor, f.CatchUpSpeed, f.HasCombatTarget, t),
				LoafEligible = (!f.HasCombatTarget && !f.HasFollowOverride && !f.HasSceneSpot && !f.HasStaySpot && f.Now >= f.FaceUntil + t.LoafReengageGraceSeconds)
			};
			if (!f.HasTargetAndAgent)
			{
				result.Mode = FollowMode.Hold;
				result.Hold = HoldReason.NoTargetOrAgent;
				return result;
			}
			if (!f.TargetSane)
			{
				result.Mode = FollowMode.Hold;
				result.Hold = HoldReason.VoidStaging;
				return result;
			}
			if (f.AgentSuspendedExternally)
			{
				result.Mode = FollowMode.Hold;
				result.Hold = HoldReason.AgentSuspended;
				return result;
			}
			bool flag = f.Now < f.LeashGraceUntil;
			float val = ((f.HasCombatTarget || flag) ? f.CombatLeashDistance : f.LeashDistance);
			float num = Math.Max(t.ZoneReplaceDistance, val);
			bool flag2 = f.Now - f.LastReplaceAt > t.ReplaceThrottleSeconds;
			if (f.AgentAbandoned)
			{
				result.Mode = FollowMode.Direct;
				bool flag3 = flag;
				bool flag4 = !f.HasCombatTarget && f.DistToOwner > (flag3 ? f.CombatLeashDistance : f.LeashDistance);
				result.PreReplaceOwner = !f.SuppressLeashWarp && (f.DistToOwner > num || flag4) && flag2;
				return result;
			}
			if (!f.GoalOnMesh)
			{
				float num2 = (f.GoalIsOwner ? num : t.ZoneReplaceDistance);
				result.Mode = FollowMode.Direct;
				result.PreReplaceOwner = !f.SuppressLeashWarp && f.DistToOwner > num2 && flag2;
				return result;
			}
			bool flag5 = !f.SuppressLeashWarp && f.DistToOwner > num;
			if (!f.AgentOnMesh || flag5)
			{
				result.Mode = FollowMode.Replace;
				result.ReplaceNow = flag2;
				result.ReplaceDest = (flag5 ? ReplaceDestination.Owner : ReplaceDestination.Goal);
				result.ReplaceMeasurable = ReplaceConvergence.IsMeasurable(flag5, f.GoalIsOwner);
				return result;
			}
			result.Mode = FollowMode.Agent;
			return result;
		}

		public static float FollowSpeed(float distToRef, float baseSpeed, float floor, float catchUp, bool hasCombatTarget, FollowTuning t)
		{
			if (hasCombatTarget)
			{
				return baseSpeed;
			}
			float num = Math.Max(baseSpeed, floor);
			if (catchUp <= 0f)
			{
				return num;
			}
			float num2 = Math.Max(floor, catchUp);
			num = Math.Min(num, num2);
			if (distToRef <= t.CatchUpNearMeters)
			{
				return num;
			}
			float num3 = Math.Max(t.CatchUpRampMeters, 0.001f);
			float num4 = Math.Min(1f, (distToRef - t.CatchUpNearMeters) / num3);
			return num + (num2 - num) * num4;
		}

		public static bool ApproachDestination(float ownerX, float ownerZ, bool hasDir, float dirX, float dirZ, float distToOwner, float behindMeters, FollowTuning t, out float x, out float z)
		{
			return ApproachDestination(ownerX, ownerZ, hasDir, dirX, dirZ, distToOwner, behindMeters, float.NaN, float.NaN, wasApproaching: false, t, out x, out z);
		}

		public static bool ApproachDestination(float ownerX, float ownerZ, bool hasDir, float dirX, float dirZ, float distToOwner, float behindMeters, float petX, float petZ, bool wasApproaching, FollowTuning t, out float x, out float z)
		{
			bool refused;
			return ApproachDestination(ownerX, ownerZ, hasDir, dirX, dirZ, distToOwner, behindMeters, petX, petZ, wasApproaching, wasRefused: false, t, out x, out z, out refused);
		}

		public static bool ApproachDestination(float ownerX, float ownerZ, bool hasDir, float dirX, float dirZ, float distToOwner, float behindMeters, float petX, float petZ, bool wasApproaching, bool wasRefused, FollowTuning t, out float x, out float z, out bool refused)
		{
			x = ownerX;
			z = ownerZ;
			refused = false;
			if (!hasDir || behindMeters <= 0f)
			{
				return false;
			}
			float num = (float)Math.Sqrt(dirX * dirX + dirZ * dirZ);
			if (num < 1E-05f)
			{
				return false;
			}
			x = ownerX - dirX / num * behindMeters;
			z = ownerZ - dirZ / num * behindMeters;
			if (!float.IsNaN(petX) && !float.IsNaN(petZ))
			{
				float num2 = x - petX;
				float num3 = z - petZ;
				float num4 = ownerX - petX;
				float num5 = ownerZ - petZ;
				float num6 = num2 * num2 + num3 * num3;
				if (num6 > 1E-06f)
				{
					float num7 = (num4 * num2 + num5 * num3) / num6;
					float num8 = petX + num2 * num7;
					float num9 = petZ + num3 * num7;
					float num10 = (ownerX - num8) * (ownerX - num8) + (ownerZ - num9) * (ownerZ - num9);
					float num11 = (wasRefused ? t.ApproachRefuseExitMeters : t.ApproachRefuseEnterMeters);
					if (num7 > 0f && num7 < 1f && num10 < num11 * num11)
					{
						refused = true;
						return false;
					}
				}
				if (wasApproaching)
				{
					float num12 = x - petX;
					float num13 = z - petZ;
					return num12 * num12 + num13 * num13 > t.ApproachArriveMeters * t.ApproachArriveMeters;
				}
			}
			return distToOwner > t.ApproachFarMeters;
		}

		public static float OwnerScaledSpeed(float speed, float ownerMultiplier)
		{
			if (float.IsNaN(ownerMultiplier) || float.IsInfinity(ownerMultiplier) || ownerMultiplier < 1f)
			{
				ownerMultiplier = 1f;
			}
			return speed * ownerMultiplier;
		}

		public static void AgentDynamics(bool hasCombatTarget, FollowTuning t, out float angularSpeed, out float acceleration)
		{
			AgentDynamics(hasCombatTarget, 0f, t, out angularSpeed, out acceleration);
		}

		public static void AgentDynamics(bool hasCombatTarget, float driveSpeed, FollowTuning t, out float angularSpeed, out float acceleration)
		{
			angularSpeed = (hasCombatTarget ? t.CombatAngularSpeed : t.FollowAngularSpeed);
			acceleration = (hasCombatTarget ? t.CombatAcceleration : t.FollowAcceleration);
			if (!hasCombatTarget && driveSpeed > 0f && t.BrakeWithinMeters > 0f)
			{
				acceleration = Math.Max(acceleration, driveSpeed * driveSpeed / (2f * t.BrakeWithinMeters));
			}
		}

		public static void WarpOffset(float fx, float fz, float rx, float rz, FollowTuning t, out float ox, out float oz)
		{
			WarpOffset(fx, fz, rx, rz, t.WarpBehindMeters, t, out ox, out oz);
		}

		public static int WarpBehindLadder(FollowTuning t, float[] into)
		{
			int num = 0;
			for (float num2 = t.WarpBehindMeters; num2 <= t.WarpBehindMaxMeters + 0.001f; num2 += Math.Max(t.WarpBehindStepMeters, 0.5f))
			{
				if (num >= into.Length)
				{
					break;
				}
				into[num++] = num2;
			}
			return num;
		}

		public static bool IsOffscreen(float vx, float vy, float vz, FollowTuning t)
		{
			if (!(vz <= 0f) && !(vx < 0f - t.OffscreenMargin) && !(vx > 1f + t.OffscreenMargin) && !(vy < 0f - t.OffscreenMargin))
			{
				return vy > 1f + t.OffscreenMargin;
			}
			return true;
		}

		public static void WarpOffset(float fx, float fz, float rx, float rz, float behind, FollowTuning t, out float ox, out float oz)
		{
			ox = (oz = 0f);
			float num = (float)Math.Sqrt(fx * fx + fz * fz);
			if (!(num < 0.0001f))
			{
				fx /= num;
				fz /= num;
				float num2 = (float)Math.Sqrt(rx * rx + rz * rz);
				if (num2 < 0.0001f)
				{
					rx = fz;
					rz = 0f - fx;
					num2 = 1f;
				}
				rx /= num2;
				rz /= num2;
				ox = (0f - fx) * behind + rx * t.WarpSideMeters;
				oz = (0f - fz) * behind + rz * t.WarpSideMeters;
			}
		}

		public static AgentDrivePlan PlanAgentDrive(in AgentDriveFacts f, FollowTuning t)
		{
			AgentDrivePlan result = new AgentDrivePlan
			{
				Planted = f.WasPlanted
			};
			if (f.HasCombatTarget && f.HasStation)
			{
				float num = ((f.StationArriveMeters > 0f) ? f.StationArriveMeters : t.StationArriveMeters);
				if (f.StationDist <= num)
				{
					result.Planted = true;
				}
				else if (f.StationDist > num + t.PlantHysteresisMeters)
				{
					result.Planted = false;
				}
			}
			else if (f.HasCombatTarget && f.GoalDist <= f.AttackRange)
			{
				result.Planted = true;
			}
			else if (!f.HasCombatTarget || f.GoalDist > f.AttackRange + t.PlantHysteresisMeters)
			{
				result.Planted = false;
			}
			result.HoldForCombat = f.HasCombatTarget && result.Planted;
			result.PointingHold = !f.HasCombatTarget && f.Now < f.FaceUntil;
			result.AgentStopped = result.HoldForCombat || result.PointingHold;
			result.StoppingDistance = ((f.LoafActive || f.SceneSpotActive || f.ApproachActive || f.StaySpotActive || (f.HasCombatTarget && f.HasStation)) ? t.LoafArriveDistance : f.StopDistance);
			result.Repath = !result.HoldForCombat && f.Now - f.LastRepathAt > t.RepathIntervalSeconds && (!f.HasPath || f.DestMovedSq > t.RepathHysteresisSq);
			bool flag = !f.HasCombatTarget && f.Now < f.LeashGraceUntil;
			if (flag && f.LeashDist <= f.LeashDistance)
			{
				result.GraceEnded = true;
				flag = false;
			}
			float num2 = ((f.HasCombatTarget || flag) ? f.CombatLeashDistance : f.LeashDistance);
			bool flag2 = (result.CantReachNow = !f.PathPending && !f.PathComplete);
			bool flag3 = flag2 && f.CantReachSince >= 0f && f.Now - f.CantReachSince >= t.CantReachGraceSeconds;
			bool flag4 = f.LeashDist > num2;
			bool flag5 = !f.HasCombatTarget && !flag && !f.StaySpotActive && flag3 && f.LeashDist > f.StopDistance + t.CantReachSlack;
			bool flag6 = (flag4 || flag5) && f.Now - f.LastWarpAt > t.LeashWarpThrottleSeconds;
			result.LeashWarp = flag6 && !f.SuppressLeashWarp;
			result.LeashWarpReason = (result.LeashWarp ? (flag4 ? WarpReason.Leash : WarpReason.CantReach) : WarpReason.None);
			result.ClearWarpBlocked = !flag6 && f.LeashDist <= num2 && !flag2;
			return result;
		}
	}
	public enum GuardEndResult
	{
		Closed,
		AlreadyClosed,
		StaleToken
	}
	public sealed class GuardWindow
	{
		private int _nextToken;

		public double ExpirySeconds { get; }

		public int Owner { get; private set; }

		public double ExpireAt { get; private set; }

		public GuardWindow(double expirySeconds)
		{
			ExpirySeconds = expirySeconds;
		}

		public bool Active(double now)
		{
			if (Owner != 0)
			{
				return now < ExpireAt;
			}
			return false;
		}

		public bool Expired(double now)
		{
			if (Owner != 0)
			{
				return now >= ExpireAt;
			}
			return false;
		}

		public int Begin(double now)
		{
			Owner = ++_nextToken;
			ExpireAt = now + ExpirySeconds;
			return Owner;
		}

		public bool Refresh(int token, double now)
		{
			if (token == 0 || token != Owner)
			{
				return false;
			}
			ExpireAt = now + ExpirySeconds;
			return true;
		}

		public GuardEndResult End(int token)
		{
			if (Owner == 0)
			{
				return GuardEndResult.AlreadyClosed;
			}
			if (token != Owner)
			{
				return GuardEndResult.StaleToken;
			}
			Owner = 0;
			return GuardEndResult.Closed;
		}
	}
	public sealed class HarvestPacing
	{
		public const float DefaultRetryCooldownSeconds = 60f;

		public const int DefaultMaxCyclesPerSession = 9;

		public const int DefaultMaxCooldownRearmsPerEpisode = 3;

		private float _nextAt;

		private string _scene;

		private int _rearms;

		private bool _parkWarned;

		public float RetryCooldownSeconds { get; }

		public int MaxCyclesPerSession { get; }

		public int MaxCooldownRearmsPerEpisode { get; }

		public bool HasAttempted => _scene != null;

		public string LastScene => _scene;

		public HarvestPacing(float retryCooldownSeconds = 60f, int maxCyclesPerSession = 9, int maxCooldownRearmsPerEpisode = 3)
		{
			RetryCooldownSeconds = retryCooldownSeconds;
			MaxCyclesPerSession = maxCyclesPerSession;
			MaxCooldownRearmsPerEpisode = maxCooldownRearmsPerEpisode;
		}

		public bool TryEarlyRearm(string sceneNow, float now)
		{
			if (_scene == null || SameScene(sceneNow, _scene) || now >= _nextAt)
			{
				return false;
			}
			_nextAt = 0f;
			_rearms = 0;
			_parkWarned = false;
			return true;
		}

		public bool IsCooldownRearm(string sceneNow)
		{
			if (_scene != null)
			{
				return SameScene(sceneNow, _scene);
			}
			return false;
		}

		private static bool SameScene(string a, string b)
		{
			return string.Equals(a, b, StringComparison.OrdinalIgnoreCase);
		}

		public bool Allowed(int cyclesThisSession, string sceneNow)
		{
			if (cyclesThisSession < MaxCyclesPerSession)
			{
				if (IsCooldownRearm(sceneNow))
				{
					return _rearms < MaxCooldownRearmsPerEpisode;
				}
				return true;
			}
			return false;
		}

		public bool TryPark(bool allowed, bool wantsBody, float now)
		{
			if (allowed || _parkWarned || !wantsBody || now < _nextAt)
			{
				return false;
			}
			_parkWarned = true;
			_nextAt = float.MaxValue;
			return true;
		}

		public bool ReadyToAttempt(bool allowed, bool wantsBody, float now)
		{
			if (allowed && wantsBody)
			{
				return now >= _nextAt;
			}
			return false;
		}

		public void NoteAttempt(string sceneNow, float now)
		{
			if (IsCooldownRearm(sceneNow))
			{
				_rearms++;
			}
			_nextAt = now + RetryCooldownSeconds;
			_scene = sceneNow;
		}
	}
	public static class HostilityRepair
	{
		public const float DefaultCooldownSeconds = 5f;

		public const float CheckerSilentSeconds = 2f;

		public static bool IsStale(bool exists, bool alive)
		{
			if (exists)
			{
				return !alive;
			}
			return true;
		}

		public static bool CheckerWedged(bool coroutineLive, int engagedCount, float now, float lastSignalAt, float silentSeconds)
		{
			if (!coroutineLive)
			{
				return false;
			}
			if (engagedCount <= 0)
			{
				return false;
			}
			if (lastSignalAt < 0f)
			{
				return false;
			}
			if (now < lastSignalAt)
			{
				return false;
			}
			return now - lastSignalAt >= silentSeconds;
		}

		public static int OverhangToTrim(int parallelCount, int checkingCount)
		{
			if (parallelCount <= checkingCount)
			{
				return 0;
			}
			return parallelCount - checkingCount;
		}

		public static bool RepairDue(float now, float lastRepairAt, float cooldownSeconds)
		{
			if (lastRepairAt < 0f)
			{
				return true;
			}
			if (cooldownSeconds <= 0f)
			{
				return true;
			}
			if (now < lastRepairAt)
			{
				return true;
			}
			return now - lastRepairAt >= cooldownSeconds;
		}
	}
	public struct IdleFacingDecision
	{
		public bool ReAim;

		public float DirX;

		public float DirZ;

		public float TurnRateDegPerSec;
	}
	public sealed class IdleFacingPolicy
	{
		public const float DefaultEngageAngleDeg = 40f;

		public const float DefaultReleaseAngleDeg = 8f;

		public const float DefaultDeadZone = 1f;

		public const float DefaultTurnRateDegPerSec = 120f;

		private bool _reAiming;

		public bool ReAiming => _reAiming;

		public void Reset()
		{
			_reAiming = false;
		}

		public IdleFacingDecision Decide(float heldX, float heldZ, float toOwnerX, float toOwnerZ, float engageAngleDeg = 40f, float releaseAngleDeg = 8f, float deadZone = 1f, float turnRateDegPerSec = 120f)
		{
			double num = Math.Sqrt((double)toOwnerX * (double)toOwnerX + (double)toOwnerZ * (double)toOwnerZ);
			if (num < (double)deadZone || num < 1E-06)
			{
				_reAiming = false;
				return default(IdleFacingDecision);
			}
			float num2 = (float)((double)toOwnerX / num);
			float num3 = (float)((double)toOwnerZ / num);
			double num4 = Math.Sqrt((double)heldX * (double)heldX + (double)heldZ * (double)heldZ);
			if (num4 < 1E-06)
			{
				_reAiming = true;
				return new IdleFacingDecision
				{
					ReAim = true,
					DirX = num2,
					DirZ = num3,
					TurnRateDegPerSec = turnRateDegPerSec
				};
			}
			float num5 = AngleBetweenDeg((float)((double)heldX / num4), (float)((double)heldZ / num4), num2, num3);
			if (_reAiming)
			{
				if (num5 <= releaseAngleDeg)
				{
					_reAiming = false;
				}
			}
			else if (num5 >= engageAngleDeg)
			{
				_reAiming = true;
			}
			return new IdleFacingDecision
			{
				ReAim = _reAiming,
				DirX = num2,
				DirZ = num3,
				TurnRateDegPerSec = turnRateDegPerSec
			};
		}

		public static float AngleBetweenDeg(float ax, float az, float bx, float bz)
		{
			double num = (double)ax * (double)bx + (double)az * (double)bz;
			if (num > 1.0)
			{
				num = 1.0;
			}
			else if (num < -1.0)
			{
				num = -1.0;
			}
			return (float)(Math.Acos(num) * 180.0 / Math.PI);
		}
	}
	public readonly struct ItemKey
	{
		public string Key { get; }

		public int? ItemId { get; }

		public ItemKey(string key, int? itemId)
		{
			Key = key;
			ItemId = itemId;
		}

		public static bool TryRead(object? jsonValue, out ItemKey key)
		{
			if (jsonValue is double num)
			{
				if (double.IsNaN(num) || num > 2147483647.0 || num < -2147483648.0)
				{
					key = default(ItemKey);
					return false;
				}
				int value = (int)num;
				key = new ItemKey(value.ToString(CultureInfo.InvariantCulture), value);
				return true;
			}
			if (jsonValue is string text)
			{
				string text2 = text.Trim();
				if (text2.Length > 0)
				{
					int? itemId = null;
					if (int.TryParse(text2, NumberStyles.Integer, CultureInfo.InvariantCulture, out var result))
					{
						itemId = result;
					}
					key = new ItemKey(text2, itemId);
					return true;
				}
			}
			key = default(ItemKey);
			return false;
		}

		public bool Matches(int liveId, string? liveName)
		{
			if (ItemId.HasValue)
			{
				return ItemId.Value == liveId;
			}
			if (!string.IsNullOrEmpty(liveName))
			{