using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using Microsoft.CodeAnalysis;
using Ravengates.Core;
using Ravengates.Mathematics;
using Ravengates.Physics;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("Ravengates.Core")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.3.0.0")]
[assembly: AssemblyInformationalVersion("1.3.0")]
[assembly: AssemblyProduct("Ravengates.Core")]
[assembly: AssemblyTitle("Ravengates.Core")]
[assembly: AssemblyVersion("1.3.0.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

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

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

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace Ravengates.Streaming
{
	public enum RemoteInterestTier
	{
		RenderOnly,
		Interactive,
		CrossingReady
	}
	[Flags]
	public enum PortalRemoteSimulation
	{
		None = 0,
		ExistingCharacters = 1,
		ExistingRigidbodies = 2,
		Physics = 4,
		Projectiles = 8,
		AI = 0x10,
		Spawners = 0x20,
		Environment = 0x40,
		Full = 0x7F
	}
	public readonly struct ZoneCoordinate : IEquatable<ZoneCoordinate>
	{
		public int X { get; }

		public int Y { get; }

		public ZoneCoordinate(int x, int y)
		{
			X = x;
			Y = y;
		}

		public static ZoneCoordinate FromWorld(Vector3 position, float zoneSize = 64f)
		{
			if (zoneSize <= 0f)
			{
				throw new ArgumentOutOfRangeException("zoneSize");
			}
			float num = zoneSize * 0.5f;
			return new ZoneCoordinate((int)Math.Floor((position.X + num) / zoneSize), (int)Math.Floor((position.Z + num) / zoneSize));
		}

		public bool Equals(ZoneCoordinate other)
		{
			if (X == other.X)
			{
				return Y == other.Y;
			}
			return false;
		}

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

		public override int GetHashCode()
		{
			return (X * 397) ^ Y;
		}

		public override string ToString()
		{
			return $"{X},{Y}";
		}
	}
	public readonly struct RemoteInterestRequest
	{
		public string OwnerKey { get; }

		public string SourcePortalId { get; }

		public string DestinationPortalId { get; }

		public Vector3 DestinationPosition { get; }

		public int Radius { get; }

		public RemoteInterestTier Tier { get; }

		public PortalRemoteSimulation Simulation { get; }

		public RemoteInterestRequest(string ownerKey, string sourcePortalId, string destinationPortalId, Vector3 destinationPosition, int radius, RemoteInterestTier tier, PortalRemoteSimulation simulation)
		{
			OwnerKey = ownerKey ?? throw new ArgumentNullException("ownerKey");
			SourcePortalId = sourcePortalId ?? throw new ArgumentNullException("sourcePortalId");
			DestinationPortalId = destinationPortalId ?? throw new ArgumentNullException("destinationPortalId");
			DestinationPosition = destinationPosition;
			Radius = Math.Max(0, radius);
			Tier = tier;
			Simulation = simulation;
		}
	}
	public sealed class RemoteZoneInterest
	{
		public ZoneCoordinate Zone { get; }

		public int ReferenceCount { get; internal set; }

		public RemoteInterestTier Tier { get; internal set; }

		public PortalRemoteSimulation Simulation { get; internal set; }

		public double UnloadAt { get; internal set; }

		public bool IsGraceUnloading
		{
			get
			{
				if (ReferenceCount == 0)
				{
					return !double.IsPositiveInfinity(UnloadAt);
				}
				return false;
			}
		}

		internal RemoteZoneInterest(ZoneCoordinate zone)
		{
			Zone = zone;
			UnloadAt = double.PositiveInfinity;
		}
	}
	public sealed class PortalInterestManager
	{
		private readonly Dictionary<ZoneCoordinate, RemoteZoneInterest> _zones = new Dictionary<ZoneCoordinate, RemoteZoneInterest>();

		private readonly Dictionary<string, HashSet<ZoneCoordinate>> _owners = new Dictionary<string, HashSet<ZoneCoordinate>>(StringComparer.Ordinal);

		private readonly Stack<HashSet<ZoneCoordinate>> _freeSets = new Stack<HashSet<ZoneCoordinate>>();

		private readonly HashSet<ZoneCoordinate> _requested = new HashSet<ZoneCoordinate>();

		private readonly List<ZoneCoordinate> _expired = new List<ZoneCoordinate>();

		public int MaxRemoteZones { get; private set; }

		public double UnloadGraceSeconds { get; private set; }

		public float ZoneSize { get; }

		public IEnumerable<RemoteZoneInterest> ActiveZones => _zones.Values;

		public PortalInterestManager(int maxRemoteZones = 49, double unloadGraceSeconds = 10.0, float zoneSize = 64f)
		{
			if (maxRemoteZones < 1)
			{
				throw new ArgumentOutOfRangeException("maxRemoteZones");
			}
			if (unloadGraceSeconds < 0.0)
			{
				throw new ArgumentOutOfRangeException("unloadGraceSeconds");
			}
			if (zoneSize <= 0f)
			{
				throw new ArgumentOutOfRangeException("zoneSize");
			}
			MaxRemoteZones = maxRemoteZones;
			UnloadGraceSeconds = unloadGraceSeconds;
			ZoneSize = zoneSize;
		}

		public void Configure(int maxRemoteZones, double unloadGraceSeconds)
		{
			if (maxRemoteZones < 1)
			{
				throw new ArgumentOutOfRangeException("maxRemoteZones");
			}
			if (double.IsNaN(unloadGraceSeconds) || double.IsInfinity(unloadGraceSeconds) || unloadGraceSeconds < 0.0)
			{
				throw new ArgumentOutOfRangeException("unloadGraceSeconds");
			}
			MaxRemoteZones = maxRemoteZones;
			UnloadGraceSeconds = unloadGraceSeconds;
		}

		public void Clear()
		{
			_owners.Clear();
			_zones.Clear();
		}

		public bool TryAcquire(RemoteInterestRequest request, double now)
		{
			HashSet<ZoneCoordinate> hashSet = CalculateZones(request, _requested);
			int num = hashSet.Count;
			if (_owners.TryGetValue(request.OwnerKey, out HashSet<ZoneCoordinate> value))
			{
				foreach (ZoneCoordinate item in value)
				{
					if (hashSet.Contains(item))
					{
						num--;
					}
				}
			}
			if (CountNonGraceZones() + Math.Max(0, num) > MaxRemoteZones)
			{
				return false;
			}
			Release(request.OwnerKey, now);
			HashSet<ZoneCoordinate> hashSet2 = ((_freeSets.Count > 0) ? _freeSets.Pop() : new HashSet<ZoneCoordinate>());
			foreach (ZoneCoordinate item2 in hashSet)
			{
				if (!_zones.TryGetValue(item2, out RemoteZoneInterest value2))
				{
					value2 = new RemoteZoneInterest(item2);
					_zones.Add(item2, value2);
				}
				bool flag = value2.ReferenceCount == 0;
				value2.ReferenceCount++;
				value2.Tier = (flag ? request.Tier : ((RemoteInterestTier)Math.Max((int)value2.Tier, (int)request.Tier)));
				value2.Simulation = (flag ? request.Simulation : (value2.Simulation | request.Simulation));
				value2.UnloadAt = double.PositiveInfinity;
				hashSet2.Add(item2);
			}
			_owners[request.OwnerKey] = hashSet2;
			return true;
		}

		public void Release(string ownerKey, double now)
		{
			if (!_owners.TryGetValue(ownerKey, out HashSet<ZoneCoordinate> value))
			{
				return;
			}
			foreach (ZoneCoordinate item in value)
			{
				if (_zones.TryGetValue(item, out RemoteZoneInterest value2))
				{
					value2.ReferenceCount = Math.Max(0, value2.ReferenceCount - 1);
					if (value2.ReferenceCount == 0)
					{
						value2.UnloadAt = now + UnloadGraceSeconds;
					}
				}
			}
			_owners.Remove(ownerKey);
			value.Clear();
			_freeSets.Push(value);
		}

		public int Tick(double now)
		{
			int num = 0;
			List<ZoneCoordinate> expired = _expired;
			expired.Clear();
			foreach (KeyValuePair<ZoneCoordinate, RemoteZoneInterest> zone in _zones)
			{
				if (zone.Value.ReferenceCount == 0 && zone.Value.UnloadAt <= now)
				{
					expired.Add(zone.Key);
				}
			}
			foreach (ZoneCoordinate item in expired)
			{
				_zones.Remove(item);
				num++;
			}
			return num;
		}

		public bool TryGet(ZoneCoordinate zone, out RemoteZoneInterest interest)
		{
			return _zones.TryGetValue(zone, out interest);
		}

		private HashSet<ZoneCoordinate> CalculateZones(RemoteInterestRequest request, HashSet<ZoneCoordinate> zones)
		{
			ZoneCoordinate zoneCoordinate = ZoneCoordinate.FromWorld(request.DestinationPosition, ZoneSize);
			zones.Clear();
			for (int i = zoneCoordinate.X - request.Radius; i <= zoneCoordinate.X + request.Radius; i++)
			{
				for (int j = zoneCoordinate.Y - request.Radius; j <= zoneCoordinate.Y + request.Radius; j++)
				{
					zones.Add(new ZoneCoordinate(i, j));
				}
			}
			return zones;
		}

		private int CountNonGraceZones()
		{
			int num = 0;
			foreach (RemoteZoneInterest value in _zones.Values)
			{
				if (value.ReferenceCount > 0)
				{
					num++;
				}
			}
			return num;
		}
	}
}
namespace Ravengates.Rendering
{
	public sealed class PortalRenderBudget
	{
		public int MaxPassesPerFrame { get; }

		public int MaxRecursionDepth { get; }

		public float MinPortalScreenPixels { get; }

		public int PassesUsed { get; private set; }

		public PortalRenderBudget(int maxPassesPerFrame = 6, int maxRecursionDepth = 2, float minPortalScreenPixels = 64f)
		{
			if (maxPassesPerFrame < 0)
			{
				throw new ArgumentOutOfRangeException("maxPassesPerFrame");
			}
			if (maxRecursionDepth < 0)
			{
				throw new ArgumentOutOfRangeException("maxRecursionDepth");
			}
			if (minPortalScreenPixels < 0f)
			{
				throw new ArgumentOutOfRangeException("minPortalScreenPixels");
			}
			MaxPassesPerFrame = maxPassesPerFrame;
			MaxRecursionDepth = maxRecursionDepth;
			MinPortalScreenPixels = minPortalScreenPixels;
		}

		public void BeginFrame()
		{
			PassesUsed = 0;
		}

		public bool TryAcquire(float projectedPixels, int requestedDepth, out int depth)
		{
			depth = 0;
			if (projectedPixels < MinPortalScreenPixels || PassesUsed >= MaxPassesPerFrame)
			{
				return false;
			}
			depth = Math.Max(0, Math.Min(MaxRecursionDepth, requestedDepth));
			PassesUsed++;
			return true;
		}
	}
	public readonly struct PortalRenderCandidate
	{
		public Portal Portal { get; }

		public float ProjectedPixels { get; }

		public int RequestedDepth { get; }

		public float Priority { get; }

		public PortalRenderCandidate(Portal portal, float projectedPixels, int requestedDepth, float priority)
		{
			Portal = portal;
			ProjectedPixels = projectedPixels;
			RequestedDepth = requestedDepth;
			Priority = priority;
		}
	}
	public readonly struct PortalRenderPass
	{
		public Portal Portal { get; }

		public int RecursionDepth { get; }

		public float ResolutionScale { get; }

		public PortalRenderPass(Portal portal, int recursionDepth, float resolutionScale)
		{
			Portal = portal;
			RecursionDepth = recursionDepth;
			ResolutionScale = resolutionScale;
		}
	}
	public sealed class PortalRenderManager
	{
		private readonly PortalRenderBudget _budget;

		public PortalRenderManager(PortalRenderBudget budget)
		{
			_budget = budget ?? throw new ArgumentNullException("budget");
		}

		public IReadOnlyList<PortalRenderPass> BuildPlan(IEnumerable<PortalRenderCandidate> candidates)
		{
			List<PortalRenderCandidate> list = new List<PortalRenderCandidate>(candidates);
			list.Sort((PortalRenderCandidate a, PortalRenderCandidate b) => b.Priority.CompareTo(a.Priority));
			List<PortalRenderPass> list2 = new List<PortalRenderPass>();
			_budget.BeginFrame();
			foreach (PortalRenderCandidate item in list)
			{
				if (_budget.TryAcquire(item.ProjectedPixels, item.RequestedDepth, out var depth))
				{
					float resolutionScale = ((depth == 0) ? 1f : Math.Max(0.35f, 1f - (float)depth * 0.2f));
					list2.Add(new PortalRenderPass(item.Portal, depth, resolutionScale));
				}
			}
			return list2;
		}
	}
	public sealed class PortalViewHistory
	{
		private readonly Dictionary<string, string> _signatures = new Dictionary<string, string>(StringComparer.Ordinal);

		public bool BeginView(string viewKey, PortalPath path)
		{
			if (!_signatures.TryGetValue(viewKey, out string value) || value != path.Signature)
			{
				_signatures[viewKey] = path.Signature;
				return true;
			}
			return false;
		}

		public void Invalidate(string viewKey)
		{
			_signatures.Remove(viewKey);
		}

		public void Clear()
		{
			_signatures.Clear();
		}
	}
	public enum PortalViewTier
	{
		High,
		Medium,
		Low,
		Minimal
	}
	public readonly struct PortalViewSchedule
	{
		public PortalViewTier Tier { get; }

		public float ResolutionScale { get; }

		public int FrameInterval { get; }

		public PortalViewSchedule(PortalViewTier tier, float resolutionScale, int frameInterval)
		{
			Tier = tier;
			ResolutionScale = resolutionScale;
			FrameInterval = Math.Max(1, frameInterval);
		}
	}
	public static class PortalViewScheduler
	{
		public const float HighCoverage = 0.35f;

		public const float MediumCoverage = 0.12f;

		public const float EveryFrameMediumCoverage = 0.2f;

		public const int LowTierInterval = 4;

		public const int MinimalTierInterval = 8;

		public static PortalViewSchedule Select(float screenCoverage, bool nearCamera, bool adaptive, float baseScale, bool belowMinimumSize = false)
		{
			baseScale = ((float.IsNaN(baseScale) || float.IsInfinity(baseScale)) ? 1f : Math.Max(0.05f, Math.Min(1f, baseScale)));
			if (belowMinimumSize && !nearCamera)
			{
				return new PortalViewSchedule(PortalViewTier.Minimal, baseScale, 8);
			}
			if (!adaptive || nearCamera || screenCoverage >= 0.35f)
			{
				return new PortalViewSchedule(PortalViewTier.High, baseScale, 1);
			}
			if (screenCoverage >= 0.12f)
			{
				return new PortalViewSchedule(PortalViewTier.Medium, baseScale, (screenCoverage >= 0.2f) ? 1 : 2);
			}
			return new PortalViewSchedule(PortalViewTier.Low, baseScale, 4);
		}

		public static void RaiseRatesWithinBudget(PortalViewSchedule[] schedules, int count, int rendersPerFrame)
		{
			if (schedules == null)
			{
				throw new ArgumentNullException("schedules");
			}
			count = Math.Min(count, schedules.Length);
			float num = 0f;
			for (int i = 0; i < count; i++)
			{
				num += 1f / (float)schedules[i].FrameInterval;
			}
			float num2 = (float)Math.Max(1, rendersPerFrame) + 0.0001f;
			for (int j = 0; j < count; j++)
			{
				PortalViewSchedule portalViewSchedule = schedules[j];
				if (portalViewSchedule.FrameInterval != 1)
				{
					float num3 = num - 1f / (float)portalViewSchedule.FrameInterval + 1f;
					if (!(num3 > num2))
					{
						schedules[j] = new PortalViewSchedule(portalViewSchedule.Tier, portalViewSchedule.ResolutionScale, 1);
						num = num3;
					}
				}
			}
		}

		public static bool IsDue(int frame, int lastRenderedFrame, int frameInterval)
		{
			if (lastRenderedFrame >= 0 && frame - lastRenderedFrame < Math.Max(1, frameInterval))
			{
				return frame < lastRenderedFrame;
			}
			return true;
		}

		public static int QuantizeTextureSize(float pixels, int quantum = 32, int minimum = 32, int maximum = 4096)
		{
			if (quantum <= 0)
			{
				throw new ArgumentOutOfRangeException("quantum");
			}
			if (float.IsNaN(pixels) || pixels <= 0f)
			{
				return minimum;
			}
			int val = (int)Math.Ceiling(Math.Min(pixels, maximum) / (float)quantum) * quantum;
			return Math.Max(minimum, Math.Min(maximum, val));
		}
	}
}
namespace Ravengates.Physics
{
	public readonly struct PortalHearingSettings
	{
		public float Multiplier { get; }

		public float MaxRange { get; }

		public float MetresLostPer100 { get; }

		public float MinimumRange { get; }

		public bool FollowsDirection { get; }

		public PortalHearingSettings(float multiplier, float maxRange, float metresLostPer100, float minimumRange = 0.5f, bool followsDirection = true)
		{
			Multiplier = multiplier;
			MaxRange = maxRange;
			MetresLostPer100 = metresLostPer100;
			MinimumRange = minimumRange;
			FollowsDirection = followsDirection;
		}
	}
	public static class PortalAcoustics
	{
		public static float RangeThrough(Portal entrance, Vector3 origin, float range, in PortalHearingSettings settings)
		{
			Portal pair = entrance.Pair;
			if (pair == null || range <= 0f || (settings.FollowsDirection && !entrance.AllowsTraversalToPair))
			{
				return 0f;
			}
			float linkLength = (pair.Pose.Position - entrance.Pose.Position).Length();
			return RangeThrough(range, (origin - entrance.Pose.Position).Length(), linkLength, in settings);
		}

		public static float RangeThrough(float range, float toEntrance, float linkLength, in PortalHearingSettings settings)
		{
			float num = range - toEntrance;
			if (num <= 0f)
			{
				return 0f;
			}
			num *= Math.Max(0f, settings.Multiplier);
			num -= Math.Max(0f, settings.MetresLostPer100) * linkLength / 100f;
			num = Math.Min(num, settings.MaxRange);
			if (!(num >= settings.MinimumRange))
			{
				return 0f;
			}
			return num;
		}

		public static bool Hears(float toExit, float hearRange, float rangeThrough, in PortalHearingSettings settings)
		{
			if (rangeThrough > 0f && toExit <= Math.Min(hearRange, settings.MaxRange))
			{
				return toExit < rangeThrough;
			}
			return false;
		}
	}
	public readonly struct PortalCrossing
	{
		public Portal Portal { get; }

		public PortalHit Hit { get; }

		public Vector3 TravelDirection { get; }

		public float Fraction => Hit.Fraction;

		public int SourceSide => Hit.SourceSide;

		public PortalCrossing(Portal portal, PortalHit hit, Vector3 travelDirection)
		{
			Portal = portal;
			Hit = hit;
			TravelDirection = travelDirection;
		}
	}
	public static class PortalCrossingSolver
	{
		public static bool TryFindCrossing(Portal portal, Vector3 previousPosition, Vector3 currentPosition, out PortalCrossing crossing)
		{
			if (portal.IsTraversable && portal.SegmentIntersects(previousPosition, currentPosition, out var hit))
			{
				crossing = new PortalCrossing(portal, hit, currentPosition - previousPosition);
				return true;
			}
			crossing = default(PortalCrossing);
			return false;
		}

		public static PortalTravellerState ApplyCrossing(PortalTravellerState stateAtCrossing, PortalCrossing crossing, PortalTransform transform, float remainingSeconds, float planeEpsilon)
		{
			if (remainingSeconds < 0f)
			{
				throw new ArgumentOutOfRangeException("remainingSeconds");
			}
			if (planeEpsilon < 0f)
			{
				throw new ArgumentOutOfRangeException("planeEpsilon");
			}
			PortalTravellerState result = transform.TransformState(stateAtCrossing);
			Vector3 value = transform.TransformDirection(crossing.TravelDirection);
			if (value.LengthSquared() > 1E-07f)
			{
				value = Vector3.Normalize(value);
				result.Position += value * planeEpsilon;
			}
			result.Position += result.Velocity * remainingSeconds;
			return result;
		}

		public static PortalTravellerState StateAtCrossing(PortalTravellerState previous, PortalTravellerState current, PortalCrossing crossing)
		{
			float amount = Math.Max(0f, Math.Min(1f, crossing.Fraction));
			return new PortalTravellerState(Vector3.Lerp(previous.Position, current.Position, amount), Quaternion.Slerp(previous.Rotation, current.Rotation, amount), Vector3.Lerp(previous.Velocity, current.Velocity, amount), Vector3.Lerp(previous.AngularVelocity, current.AngularVelocity, amount));
		}
	}
	public interface IPortalTraveller
	{
		string TravellerId { get; }

		PortalBounds GetPortalBounds();

		PortalTravellerState GetState();

		void OnPortalEnter(Portal portal);

		void OnPortalStraddle(Portal portal, float fraction);

		void OnPortalCross(Portal source, Portal destination, PortalTravellerState transformedState);

		void OnPortalExit(Portal portal);
	}
	public sealed class PortalTravellerRegistry
	{
		private readonly Dictionary<string, IPortalTraveller> _travellers = new Dictionary<string, IPortalTraveller>(StringComparer.Ordinal);

		public bool Register(IPortalTraveller traveller)
		{
			if (_travellers.ContainsKey(traveller.TravellerId))
			{
				return false;
			}
			_travellers.Add(traveller.TravellerId, traveller);
			return true;
		}

		public bool Unregister(string travellerId)
		{
			return _travellers.Remove(travellerId);
		}

		public bool TryGet(string travellerId, out IPortalTraveller traveller)
		{
			return _travellers.TryGetValue(travellerId, out traveller);
		}
	}
	public enum PortalRaycastTermination
	{
		Hit,
		NoHit,
		MaximumPortalTraversals,
		InvalidPortal
	}
	public readonly struct PortalRayHit
	{
		public Vector3 Point { get; }

		public Vector3 Normal { get; }

		public float Distance { get; }

		public string ColliderId { get; }

		public PortalRayHit(Vector3 point, Vector3 normal, float distance, string colliderId = "")
		{
			Point = point;
			Normal = normal;
			Distance = distance;
			ColliderId = colliderId ?? string.Empty;
		}
	}
	public interface IPortalRaycastWorld
	{
		IEnumerable<Portal> Portals { get; }

		bool TryRaycast(PortalRay ray, float maxDistance, out PortalRayHit hit);
	}
	public sealed class PortalRaycastResult
	{
		public bool Hit { get; internal set; }

		public PortalRayHit SurfaceHit { get; internal set; }

		public PortalPath Path { get; internal set; } = new PortalPath();

		public PortalRaycastTermination Termination { get; internal set; }
	}
	public static class PortalRaycast
	{
		public static PortalRaycastResult Cast(IPortalRaycastWorld world, PortalRay ray, float maxDistance, int maxPortalTraversals = 8, float planeEpsilon = 0.02f)
		{
			if (maxDistance < 0f)
			{
				throw new ArgumentOutOfRangeException("maxDistance");
			}
			if (maxPortalTraversals < 0)
			{
				throw new ArgumentOutOfRangeException("maxPortalTraversals");
			}
			PortalRaycastResult portalRaycastResult = new PortalRaycastResult
			{
				Path = new PortalPath(Math.Max(1, maxPortalTraversals))
			};
			PortalRay ray2 = ray;
			float num = maxDistance;
			float num2 = 0f;
			for (int i = 0; i <= maxPortalTraversals; i++)
			{
				Portal nearestPortal;
				PortalHit nearestHit;
				float num3 = FindNearestPortalDistance(world.Portals, ray2, num, out nearestPortal, out nearestHit);
				if (world.TryRaycast(ray2, num, out var hit))
				{
					if (nearestPortal == null || hit.Distance <= num3)
					{
						portalRaycastResult.Hit = true;
						portalRaycastResult.SurfaceHit = new PortalRayHit(hit.Point, portalRaycastResult.Path.TransformDirection(hit.Normal), num2 + hit.Distance, hit.ColliderId);
						portalRaycastResult.Termination = PortalRaycastTermination.Hit;
						portalRaycastResult.Path.AddLogicalDistance(hit.Distance);
						return portalRaycastResult;
					}
				}
				else if (nearestPortal == null)
				{
					portalRaycastResult.Termination = PortalRaycastTermination.NoHit;
					return portalRaycastResult;
				}
				if (nearestPortal == null || !nearestPortal.IsTraversable || nearestPortal.Pair == null)
				{
					portalRaycastResult.Termination = PortalRaycastTermination.InvalidPortal;
					return portalRaycastResult;
				}
				if (i == maxPortalTraversals)
				{
					portalRaycastResult.Termination = PortalRaycastTermination.MaximumPortalTraversals;
					return portalRaycastResult;
				}
				float num4 = nearestHit.Fraction * num;
				if (!portalRaycastResult.Path.TryAppend(nearestPortal, nearestPortal.Pair, num4))
				{
					portalRaycastResult.Termination = PortalRaycastTermination.InvalidPortal;
					return portalRaycastResult;
				}
				PortalTransform transformToPair = nearestPortal.GetTransformToPair();
				Vector3 vector = transformToPair.TransformPoint(nearestHit.Point);
				Vector3 vector2 = Vector3.Normalize(transformToPair.TransformDirection(ray2.Direction));
				ray2 = new PortalRay(vector + vector2 * planeEpsilon, vector2);
				num -= num4;
				num -= planeEpsilon;
				num2 += num4;
				if (num <= 0f)
				{
					portalRaycastResult.Termination = PortalRaycastTermination.NoHit;
					return portalRaycastResult;
				}
			}
			portalRaycastResult.Termination = PortalRaycastTermination.MaximumPortalTraversals;
			return portalRaycastResult;
		}

		private static float FindNearestPortalDistance(IEnumerable<Portal> portals, PortalRay ray, float maxDistance, out Portal? nearestPortal, out PortalHit nearestHit)
		{
			nearestPortal = null;
			nearestHit = default(PortalHit);
			float num = float.PositiveInfinity;
			Vector3 point = ray.GetPoint(maxDistance);
			foreach (Portal portal in portals)
			{
				if (portal.IsTraversable && portal.SegmentIntersects(ray.Origin, point, out var hit))
				{
					float num2 = hit.Fraction * maxDistance;
					if (num2 < num)
					{
						num = num2;
						nearestPortal = portal;
						nearestHit = hit;
					}
				}
			}
			return num;
		}
	}
	public struct PortalTraversalGuard
	{
		public string? PortalId { get; private set; }

		public int ExitSide { get; private set; }

		public bool IsActive => PortalId != null;

		public void Arm(Portal destination, Vector3 referencePoint)
		{
			if (destination == null)
			{
				throw new ArgumentNullException("destination");
			}
			float z = destination.Pose.ToLocalPoint(referencePoint).Z;
			PortalId = destination.Id;
			ExitSide = ((z >= 0f) ? 1 : (-1));
		}

		public void Refresh(Portal? guardedPortal, Vector3 referencePoint, float clearance)
		{
			if (PortalId != null)
			{
				if (guardedPortal == null || !string.Equals(guardedPortal.Id, PortalId, StringComparison.Ordinal))
				{
					Clear();
				}
				else if (guardedPortal.Pose.ToLocalPoint(referencePoint).Z * (float)ExitSide >= clearance)
				{
					Clear();
				}
			}
		}

		public bool ShouldDefer(PortalCrossing crossing, Vector3 currentPoint, float clearance)
		{
			if (PortalId == null || crossing.Portal == null)
			{
				return false;
			}
			if (!string.Equals(crossing.Portal.Id, PortalId, StringComparison.Ordinal))
			{
				return false;
			}
			if (crossing.SourceSide != ExitSide)
			{
				return false;
			}
			return Math.Abs(crossing.Portal.Pose.ToLocalPoint(currentPoint).Z) < clearance;
		}

		public void Clear()
		{
			PortalId = null;
			ExitSide = 0;
		}
	}
	public static class PortalTraversal
	{
		public static int ExitSide(PortalCrossing crossing)
		{
			if (crossing.SourceSide < 0)
			{
				return -1;
			}
			return 1;
		}

		public static Vector3 ExitCorrection(Portal destination, Vector3 mappedReferencePoint, int exitSide, float epsilon)
		{
			if (destination == null)
			{
				throw new ArgumentNullException("destination");
			}
			float num = ((exitSide >= 0) ? 1f : (-1f));
			float num2 = destination.Pose.ToLocalPoint(mappedReferencePoint).Z * num;
			if (num2 >= epsilon)
			{
				return Vector3.Zero;
			}
			return destination.Pose.ToWorldDirection(Vector3.UnitZ) * (num * (epsilon - num2));
		}
	}
}
namespace Ravengates.Networking
{
	public readonly struct PortalTraversalRequest
	{
		public string TravellerId { get; }

		public string SourcePortalId { get; }

		public string DestinationPortalId { get; }

		public int ConnectionRevision { get; }

		public Vector3 ClientPosition { get; }

		public Vector3 ClientVelocity { get; }

		public uint Sequence { get; }

		public PortalTraversalRequest(string travellerId, string sourcePortalId, string destinationPortalId, int connectionRevision, Vector3 clientPosition, Vector3 clientVelocity, uint sequence)
		{
			TravellerId = travellerId ?? throw new ArgumentNullException("travellerId");
			SourcePortalId = sourcePortalId ?? throw new ArgumentNullException("sourcePortalId");
			DestinationPortalId = destinationPortalId ?? throw new ArgumentNullException("destinationPortalId");
			ConnectionRevision = connectionRevision;
			ClientPosition = clientPosition;
			ClientVelocity = clientVelocity;
			Sequence = sequence;
		}
	}
	public readonly struct PortalTraversalTicket
	{
		public string TravellerId { get; }

		public Portal Source { get; }

		public Portal Destination { get; }

		public PortalTransform Transform { get; }

		public PortalCrossing Crossing { get; }

		public PortalTraversalTicket(string travellerId, Portal source, Portal destination, PortalTransform transform, PortalCrossing crossing)
		{
			TravellerId = travellerId;
			Source = source;
			Destination = destination;
			Transform = transform;
			Crossing = crossing;
		}
	}
	public sealed class PortalAuthority
	{
		private readonly PortalManager _portals;

		public float MaxTravellerSpeed { get; }

		public PortalAuthority(PortalManager portals, float maxTravellerSpeed = 250f)
		{
			_portals = portals ?? throw new ArgumentNullException("portals");
			if (maxTravellerSpeed <= 0f)
			{
				throw new ArgumentOutOfRangeException("maxTravellerSpeed");
			}
			MaxTravellerSpeed = maxTravellerSpeed;
		}

		public bool TryValidate(PortalTraversalRequest request, Vector3 serverPreviousPosition, Vector3 serverCurrentPosition, Vector3 serverVelocity, out PortalTraversalTicket ticket)
		{
			ticket = default(PortalTraversalTicket);
			if (!_portals.TryResolveLinkedPair(request.SourcePortalId, request.DestinationPortalId, out Portal source, out Portal destination))
			{
				return false;
			}
			if (request.ConnectionRevision != source.ConnectionRevision || !source.IsTraversable)
			{
				return false;
			}
			if (serverVelocity.Length() > MaxTravellerSpeed)
			{
				return false;
			}
			if (!PortalCrossingSolver.TryFindCrossing(source, serverPreviousPosition, serverCurrentPosition, out var crossing))
			{
				return false;
			}
			ticket = new PortalTraversalTicket(request.TravellerId, source, destination, source.GetTransformToPair(), crossing);
			return true;
		}
	}
}
namespace Ravengates.Mathematics
{
	public readonly struct Vector3 : IEquatable<Vector3>
	{
		public float X { get; }

		public float Y { get; }

		public float Z { get; }

		public static Vector3 Zero => new Vector3(0f, 0f, 0f);

		public static Vector3 One => new Vector3(1f, 1f, 1f);

		public static Vector3 UnitX => new Vector3(1f, 0f, 0f);

		public static Vector3 UnitY => new Vector3(0f, 1f, 0f);

		public static Vector3 UnitZ => new Vector3(0f, 0f, 1f);

		public Vector3(float x, float y, float z)
		{
			X = x;
			Y = y;
			Z = z;
		}

		public float LengthSquared()
		{
			return X * X + Y * Y + Z * Z;
		}

		public float Length()
		{
			return (float)Math.Sqrt(LengthSquared());
		}

		public static float Dot(Vector3 left, Vector3 right)
		{
			return left.X * right.X + left.Y * right.Y + left.Z * right.Z;
		}

		public static Vector3 Normalize(Vector3 value)
		{
			float num = value.Length();
			if (!(num <= 1E-07f))
			{
				return value / num;
			}
			return Zero;
		}

		public static Vector3 Lerp(Vector3 a, Vector3 b, float amount)
		{
			return a + (b - a) * amount;
		}

		public static Vector3 Transform(Vector3 value, Quaternion rotation)
		{
			return Quaternion.Transform(value, rotation);
		}

		public bool Equals(Vector3 other)
		{
			if (X.Equals(other.X) && Y.Equals(other.Y))
			{
				return Z.Equals(other.Z);
			}
			return false;
		}

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

		public override int GetHashCode()
		{
			return (X.GetHashCode() * 397) ^ (Y.GetHashCode() * 17) ^ Z.GetHashCode();
		}

		public override string ToString()
		{
			return $"({X}, {Y}, {Z})";
		}

		public static Vector3 operator +(Vector3 left, Vector3 right)
		{
			return new Vector3(left.X + right.X, left.Y + right.Y, left.Z + right.Z);
		}

		public static Vector3 operator -(Vector3 left, Vector3 right)
		{
			return new Vector3(left.X - right.X, left.Y - right.Y, left.Z - right.Z);
		}

		public static Vector3 operator -(Vector3 value)
		{
			return new Vector3(0f - value.X, 0f - value.Y, 0f - value.Z);
		}

		public static Vector3 operator *(Vector3 value, float scalar)
		{
			return new Vector3(value.X * scalar, value.Y * scalar, value.Z * scalar);
		}

		public static Vector3 operator *(float scalar, Vector3 value)
		{
			return value * scalar;
		}

		public static Vector3 operator /(Vector3 value, float scalar)
		{
			return new Vector3(value.X / scalar, value.Y / scalar, value.Z / scalar);
		}
	}
	public readonly struct Quaternion : IEquatable<Quaternion>
	{
		public float X { get; }

		public float Y { get; }

		public float Z { get; }

		public float W { get; }

		public static Quaternion Identity => new Quaternion(0f, 0f, 0f, 1f);

		public Quaternion(float x, float y, float z, float w)
		{
			X = x;
			Y = y;
			Z = z;
			W = w;
		}

		public static Quaternion CreateFromAxisAngle(Vector3 axis, float angle)
		{
			Vector3 vector = Vector3.Normalize(axis);
			float num = angle * 0.5f;
			float num2 = (float)Math.Sin(num);
			return Normalize(new Quaternion(vector.X * num2, vector.Y * num2, vector.Z * num2, (float)Math.Cos(num)));
		}

		public static Quaternion Normalize(Quaternion value)
		{
			float num = (float)Math.Sqrt(value.X * value.X + value.Y * value.Y + value.Z * value.Z + value.W * value.W);
			if (!(num <= 1E-07f))
			{
				return new Quaternion(value.X / num, value.Y / num, value.Z / num, value.W / num);
			}
			return Identity;
		}

		public static Quaternion Inverse(Quaternion value)
		{
			float num = value.X * value.X + value.Y * value.Y + value.Z * value.Z + value.W * value.W;
			if (num <= 1E-07f)
			{
				return Identity;
			}
			return new Quaternion((0f - value.X) / num, (0f - value.Y) / num, (0f - value.Z) / num, value.W / num);
		}

		public static Quaternion Slerp(Quaternion a, Quaternion b, float amount)
		{
			a = Normalize(a);
			b = Normalize(b);
			float num = a.X * b.X + a.Y * b.Y + a.Z * b.Z + a.W * b.W;
			if (num < 0f)
			{
				b = new Quaternion(0f - b.X, 0f - b.Y, 0f - b.Z, 0f - b.W);
				num = 0f - num;
			}
			if (num > 0.9995f)
			{
				return Normalize(new Quaternion(a.X + amount * (b.X - a.X), a.Y + amount * (b.Y - a.Y), a.Z + amount * (b.Z - a.Z), a.W + amount * (b.W - a.W)));
			}
			float num2 = (float)Math.Acos(Math.Max(-1f, Math.Min(1f, num)));
			float num3 = (float)Math.Sin(num2);
			float num4 = (float)Math.Sin((1f - amount) * num2) / num3;
			float num5 = (float)Math.Sin(amount * num2) / num3;
			return new Quaternion(a.X * num4 + b.X * num5, a.Y * num4 + b.Y * num5, a.Z * num4 + b.Z * num5, a.W * num4 + b.W * num5);
		}

		public static Vector3 Transform(Vector3 value, Quaternion rotation)
		{
			Quaternion quaternion = Normalize(rotation);
			Vector3 left = new Vector3(quaternion.X, quaternion.Y, quaternion.Z);
			Vector3 vector = Cross(left, value);
			Vector3 vector2 = Cross(left, vector);
			return value + vector * (2f * quaternion.W) + vector2 * 2f;
		}

		private static Vector3 Cross(Vector3 left, Vector3 right)
		{
			return new Vector3(left.Y * right.Z - left.Z * right.Y, left.Z * right.X - left.X * right.Z, left.X * right.Y - left.Y * right.X);
		}

		public bool Equals(Quaternion other)
		{
			if (X.Equals(other.X) && Y.Equals(other.Y) && Z.Equals(other.Z))
			{
				return W.Equals(other.W);
			}
			return false;
		}

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

		public override int GetHashCode()
		{
			return (((((X.GetHashCode() * 397) ^ Y.GetHashCode()) * 397) ^ Z.GetHashCode()) * 397) ^ W.GetHashCode();
		}

		public override string ToString()
		{
			return $"({X}, {Y}, {Z}, {W})";
		}

		public static Quaternion operator *(Quaternion left, Quaternion right)
		{
			return new Quaternion(left.W * right.X + left.X * right.W + left.Y * right.Z - left.Z * right.Y, left.W * right.Y - left.X * right.Z + left.Y * right.W + left.Z * right.X, left.W * right.Z + left.X * right.Y - left.Y * right.X + left.Z * right.W, left.W * right.W - left.X * right.X - left.Y * right.Y - left.Z * right.Z);
		}
	}
}
namespace Ravengates.Core
{
	public enum PortalTraversalDirection
	{
		Bidirectional,
		OutboundOnly,
		InboundOnly
	}
	public enum PortalSealedSide
	{
		None,
		Front,
		Back
	}
	[Flags]
	public enum PortalFaces
	{
		None = 0,
		Front = 1,
		Back = 2,
		Both = 3
	}
	public sealed class Portal
	{
		private Portal? _pair;

		public string Id { get; }

		public PortalPose Pose { get; private set; }

		public PortalAperture Aperture { get; private set; }

		public string Tag { get; private set; }

		public int ConnectionRevision { get; private set; }

		public int TransformRevision { get; private set; }

		public Portal? Pair => _pair;

		public bool IsLinked => _pair != null;

		public bool IsMutual
		{
			get
			{
				if (_pair != null)
				{
					return _pair._pair == this;
				}
				return false;
			}
		}

		public bool IsTraversable
		{
			get
			{
				if (IsLinked && Pose.HasFiniteValues() && Pair.Pose.HasFiniteValues() && Pose.HasUniformUnitScale())
				{
					return Pair.Pose.HasUniformUnitScale();
				}
				return false;
			}
		}

		public PortalTraversalDirection Direction { get; private set; }

		public bool AllowsTraversalToPair
		{
			get
			{
				if (IsLinked && Direction != PortalTraversalDirection.InboundOnly)
				{
					return Pair.Direction != PortalTraversalDirection.OutboundOnly;
				}
				return false;
			}
		}

		public PortalSealedSide SealedSide { get; private set; }

		public PortalFaces BlockedFaces { get; private set; }

		public Portal(string id, PortalPose pose, PortalAperture aperture, string? tag = null)
		{
			if (string.IsNullOrWhiteSpace(id))
			{
				throw new ArgumentException("A portal id is required.", "id");
			}
			Id = id;
			Pose = pose;
			Aperture = aperture;
			Tag = tag ?? string.Empty;
			ConnectionRevision = 1;
			TransformRevision = 1;
		}

		public void SetDirection(PortalTraversalDirection direction)
		{
			Direction = direction;
		}

		public void SetSealedSide(PortalSealedSide side)
		{
			SealedSide = side;
		}

		public bool IsSideOpen(int side)
		{
			if (IsLinked && !Closes(side))
			{
				return !Pair.Closes(side);
			}
			return false;
		}

		public void SetBlockedFaces(PortalFaces faces)
		{
			BlockedFaces = faces & PortalFaces.Both;
		}

		public bool IsSideBlocked(int side)
		{
			if (IsLinked)
			{
				if (!Blocks(BlockedFaces, side))
				{
					return Blocks(Pair.BlockedFaces, side);
				}
				return true;
			}
			return false;
		}

		private bool Closes(int side)
		{
			if (!Seals(SealedSide, side))
			{
				return Blocks(BlockedFaces, side);
			}
			return true;
		}

		private static bool Blocks(PortalFaces faces, int side)
		{
			if (side <= 0)
			{
				if (side < 0)
				{
					return (faces & PortalFaces.Back) != 0;
				}
				return false;
			}
			return (faces & PortalFaces.Front) != 0;
		}

		private static bool Seals(PortalSealedSide sealedSide, int side)
		{
			if (side <= 0)
			{
				if (side < 0)
				{
					return sealedSide == PortalSealedSide.Back;
				}
				return false;
			}
			return sealedSide == PortalSealedSide.Front;
		}

		public PortalTransform GetTransformToPair()
		{
			if (!IsLinked)
			{
				throw new InvalidOperationException("Portal '" + Id + "' is not linked.");
			}
			return new PortalTransform(Id, Pair.Id, Pose, Pair.Pose);
		}

		public bool ContainsWorldPoint(Vector3 point, float margin = 0f)
		{
			return Aperture.ContainsWorldPoint(Pose, point, margin);
		}

		public bool SegmentIntersects(Vector3 start, Vector3 end, out PortalHit hit)
		{
			return Aperture.SegmentIntersects(Pose, start, end, out hit);
		}

		public bool ShapeFits(PortalBounds bounds)
		{
			return Aperture.ShapeFits(Pose, bounds);
		}

		public void SetPose(PortalPose pose)
		{
			if (!pose.HasFiniteValues())
			{
				throw new ArgumentException("Portal pose must be finite.", "pose");
			}
			Pose = pose;
			TransformRevision++;
		}

		public void SetAperture(PortalAperture aperture)
		{
			Aperture = aperture;
			TransformRevision++;
		}

		public void SetTag(string tag)
		{
			Tag = tag ?? string.Empty;
			ConnectionRevision++;
		}

		internal void SetPair(Portal? pair)
		{
			_pair = pair;
			ConnectionRevision++;
		}

		public override string ToString()
		{
			return "Portal(" + Id + ", tag='" + Tag + "', pair='" + (Pair?.Id ?? "none") + "')";
		}
	}
	public sealed class PortalManager
	{
		private readonly Dictionary<string, Portal> _portals = new Dictionary<string, Portal>(StringComparer.Ordinal);

		public IEnumerable<Portal> Portals => _portals.Values;

		public bool Register(Portal portal)
		{
			if (_portals.ContainsKey(portal.Id))
			{
				return false;
			}
			_portals.Add(portal.Id, portal);
			return true;
		}

		public bool Unregister(string id)
		{
			if (!_portals.TryGetValue(id, out Portal value))
			{
				return false;
			}
			Unlink(value);
			foreach (Portal value2 in _portals.Values)
			{
				if (value2.Pair == value)
				{
					value2.SetPair(null);
				}
			}
			return _portals.Remove(id);
		}

		public bool TryGet(string id, out Portal portal)
		{
			return _portals.TryGetValue(id, out portal);
		}

		public bool TryLink(string firstId, string secondId)
		{
			if (!TryGet(firstId, out Portal portal) || !TryGet(secondId, out Portal portal2))
			{
				return false;
			}
			return TryLink(portal, portal2);
		}

		public bool TryLink(Portal first, Portal second)
		{
			if (first == second || !_portals.ContainsKey(first.Id) || !_portals.ContainsKey(second.Id))
			{
				return false;
			}
			if (first.IsMutual && first.Pair == second)
			{
				return true;
			}
			if (first.IsLinked)
			{
				Unlink(first);
			}
			if (second.IsLinked)
			{
				Unlink(second);
			}
			first.SetPair(second);
			second.SetPair(first);
			return true;
		}

		public bool TryLinkOneWay(Portal source, Portal exit)
		{
			if (source == exit || !_portals.ContainsKey(source.Id) || !_portals.ContainsKey(exit.Id))
			{
				return false;
			}
			if (source.Pair == exit)
			{
				return true;
			}
			if (source.IsLinked)
			{
				Unlink(source);
			}
			source.SetPair(exit);
			return true;
		}

		public void Unlink(Portal portal)
		{
			Portal pair = portal.Pair;
			portal.SetPair(null);
			if (pair != null && pair.Pair == portal)
			{
				pair.SetPair(null);
			}
		}

		public bool TryResolveLinkedPair(string sourceId, string destinationId, out Portal source, out Portal destination)
		{
			source = null;
			destination = null;
			if (!TryGet(sourceId, out source) || !TryGet(destinationId, out destination))
			{
				return false;
			}
			if (source.IsLinked)
			{
				return source.Pair == destination;
			}
			return false;
		}
	}
	public enum PortalApertureShape
	{
		Ellipse,
		RoundedRectangle,
		RadialProfile
	}
	public readonly struct PortalHit
	{
		public float Fraction { get; }

		public Vector3 Point { get; }

		public Vector3 LocalPoint { get; }

		public int SourceSide { get; }

		public PortalHit(float fraction, Vector3 point, Vector3 localPoint, int sourceSide)
		{
			Fraction = fraction;
			Point = point;
			LocalPoint = localPoint;
			SourceSide = sourceSide;
		}
	}
	public readonly struct PortalAperture
	{
		private readonly float[]? _radii;

		public float Width { get; }

		public float Height { get; }

		public PortalApertureShape Shape { get; }

		public float CornerRadius { get; }

		public int RadialSampleCount
		{
			get
			{
				float[]? radii = _radii;
				if (radii == null)
				{
					return 0;
				}
				return radii.Length;
			}
		}

		public PortalAperture(float width, float height, PortalApertureShape shape = PortalApertureShape.Ellipse, float cornerRadius = 0.25f)
		{
			if (width <= 0f)
			{
				throw new ArgumentOutOfRangeException("width");
			}
			if (height <= 0f)
			{
				throw new ArgumentOutOfRangeException("height");
			}
			if (shape == PortalApertureShape.RadialProfile)
			{
				throw new ArgumentException("Use the radial-profile constructor for measured openings.", "shape");
			}
			Width = width;
			Height = height;
			Shape = shape;
			CornerRadius = Math.Max(0f, cornerRadius);
			_radii = null;
		}

		public PortalAperture(float[] radialProfile)
		{
			if (radialProfile == null)
			{
				throw new ArgumentNullException("radialProfile");
			}
			if (radialProfile.Length < 8)
			{
				throw new ArgumentException("At least eight radial samples are required.", "radialProfile");
			}
			float[] array = new float[radialProfile.Length];
			float num = 0f;
			float num2 = 0f;
			float num3 = 0f;
			float num4 = 0f;
			for (int i = 0; i < array.Length; i++)
			{
				float num5 = radialProfile[i];
				if (float.IsNaN(num5) || float.IsInfinity(num5) || num5 <= 0f)
				{
					throw new ArgumentOutOfRangeException("radialProfile", "Radial samples must be finite and positive.");
				}
				array[i] = num5;
				double num6 = Math.PI * 2.0 * (double)i / (double)array.Length;
				float val = (float)(Math.Cos(num6) * (double)num5);
				float val2 = (float)(Math.Sin(num6) * (double)num5);
				num = Math.Min(num, val);
				num2 = Math.Max(num2, val);
				num3 = Math.Min(num3, val2);
				num4 = Math.Max(num4, val2);
			}
			_radii = array;
			Width = Math.Max(0.0001f, 2f * Math.Max(0f - num, num2));
			Height = Math.Max(0.0001f, 2f * Math.Max(0f - num3, num4));
			Shape = PortalApertureShape.RadialProfile;
			CornerRadius = 0f;
		}

		public float RadiusAtAngle(float angle)
		{
			if (_radii != null)
			{
				double num = (double)angle / (Math.PI * 2.0);
				double num2 = (num - Math.Floor(num)) * (double)_radii.Length;
				int num3 = (int)Math.Floor(num2);
				float num4 = (float)(num2 - (double)num3);
				float num5 = _radii[num3 % _radii.Length];
				float num6 = _radii[(num3 + 1) % _radii.Length];
				return num5 + (num6 - num5) * num4;
			}
			double num7 = Math.Cos(angle);
			double num8 = Math.Sin(angle);
			double num9 = (double)Width * 0.5;
			double num10 = (double)Height * 0.5;
			if (Shape == PortalApertureShape.RoundedRectangle)
			{
				double val = ((Math.Abs(num7) < 1E-06) ? double.MaxValue : (num9 / Math.Abs(num7)));
				double val2 = ((Math.Abs(num8) < 1E-06) ? double.MaxValue : (num10 / Math.Abs(num8)));
				return (float)Math.Min(val, val2);
			}
			double d = num7 * num7 / (num9 * num9) + num8 * num8 / (num10 * num10);
			return (float)(1.0 / Math.Sqrt(d));
		}

		public bool ContainsWorldPoint(PortalPose portalPose, Vector3 point, float margin = 0f)
		{
			Vector3 localPoint = portalPose.ToLocalPoint(point);
			return ContainsLocalPoint(localPoint, margin);
		}

		public bool ContainsLocalPoint(Vector3 localPoint, float margin = 0f)
		{
			if (Shape == PortalApertureShape.RadialProfile)
			{
				float num = (float)Math.Sqrt(localPoint.X * localPoint.X + localPoint.Y * localPoint.Y);
				float angle = (float)Math.Atan2(localPoint.Y, localPoint.X);
				if (num <= RadiusAtAngle(angle) + margin)
				{
					return Math.Abs(localPoint.Z) <= 0.05f;
				}
				return false;
			}
			float num2 = Math.Max(0.0001f, Width * 0.5f + margin);
			float num3 = Math.Max(0.0001f, Height * 0.5f + margin);
			if (Shape == PortalApertureShape.RoundedRectangle)
			{
				float num4 = Math.Min(CornerRadius + Math.Max(0f, margin), Math.Min(num2, num3));
				float num5 = Math.Max(Math.Abs(localPoint.X) - (num2 - num4), 0f);
				float num6 = Math.Max(Math.Abs(localPoint.Y) - (num3 - num4), 0f);
				if (num5 * num5 + num6 * num6 <= num4 * num4)
				{
					return Math.Abs(localPoint.Z) <= 0.05f;
				}
				return false;
			}
			float num7 = localPoint.X / num2;
			float num8 = localPoint.Y / num3;
			if (num7 * num7 + num8 * num8 <= 1f)
			{
				return Math.Abs(localPoint.Z) <= 0.05f;
			}
			return false;
		}

		public bool SegmentIntersects(PortalPose portalPose, Vector3 start, Vector3 end, out PortalHit hit)
		{
			Vector3 vector = portalPose.ToLocalPoint(start);
			Vector3 vector2 = portalPose.ToLocalPoint(end);
			float z = vector.Z;
			float z2 = vector2.Z;
			bool num = (z < -1E-05f && z2 > 1E-05f) || (z > 1E-05f && z2 < -1E-05f);
			float num2 = 0f;
			if (num)
			{
				num2 = z / (z - z2);
			}
			else
			{
				if (!(Math.Abs(z) <= 1E-05f) || !(Math.Abs(z2) > 1E-05f))
				{
					hit = default(PortalHit);
					return false;
				}
				num2 = 0f;
			}
			num2 = Math.Max(0f, Math.Min(1f, num2));
			Vector3 localPoint = vector + (vector2 - vector) * num2;
			if (!ContainsLocalPoint(localPoint))
			{
				hit = default(PortalHit);
				return false;
			}
			int num3 = Math.Sign(z);
			if (num3 == 0)
			{
				num3 = Math.Sign(z2);
			}
			hit = new PortalHit(num2, portalPose.ToWorldPoint(localPoint), localPoint, num3);
			return true;
		}

		public bool FitsUprightCapsule(float radius, float height, float margin = 0f)
		{
			radius = Math.Max(0f, radius);
			height = Math.Max(height, radius * 2f);
			float num = 0f - RadiusAtAngle(4.712389f);
			float y = num + radius;
			float y2 = num + height - radius;
			if (ContainsLocalPoint(new Vector3(0f - radius, y, 0f), 0f - margin) && ContainsLocalPoint(new Vector3(radius, y, 0f), 0f - margin) && ContainsLocalPoint(new Vector3(0f - radius, y2, 0f), 0f - margin) && ContainsLocalPoint(new Vector3(radius, y2, 0f), 0f - margin))
			{
				return ContainsLocalPoint(new Vector3(0f, num + height, 0f), 0f - margin);
			}
			return false;
		}

		public bool ShapeFits(PortalPose portalPose, PortalBounds bounds)
		{
			Vector3 vector = portalPose.ToLocalPoint(bounds.Center);
			Vector3 vector2 = new Vector3(Math.Abs(bounds.Extents.X) + Math.Abs(bounds.Extents.Y) + Math.Abs(bounds.Extents.Z), Math.Abs(bounds.Extents.X) + Math.Abs(bounds.Extents.Y) + Math.Abs(bounds.Extents.Z), 0f);
			if (Shape == PortalApertureShape.RadialProfile)
			{
				for (int i = -1; i <= 1; i += 2)
				{
					for (int j = -1; j <= 1; j += 2)
					{
						if (!ContainsLocalPoint(new Vector3(vector.X + (float)i * vector2.X, vector.Y + (float)j * vector2.Y, 0f)))
						{
							return false;
						}
					}
				}
				return true;
			}
			if (Shape == PortalApertureShape.RoundedRectangle)
			{
				if (Math.Abs(vector.X) + vector2.X <= Width * 0.5f)
				{
					return Math.Abs(vector.Y) + vector2.Y <= Height * 0.5f;
				}
				return false;
			}
			float num = Math.Max(0.0001f, Width * 0.5f);
			float num2 = Math.Max(0.0001f, Height * 0.5f);
			float num3 = (Math.Abs(vector.X) + vector2.X) / num;
			float num4 = (Math.Abs(vector.Y) + vector2.Y) / num2;
			return num3 * num3 + num4 * num4 <= 1f;
		}
	}
	public readonly struct PortalPathStep
	{
		public PortalTransform Transform { get; }

		public int SourceConnectionRevision { get; }

		public int DestinationConnectionRevision { get; }

		public PortalPathStep(PortalTransform transform, int sourceConnectionRevision, int destinationConnectionRevision)
		{
			Transform = transform;
			SourceConnectionRevision = sourceConnectionRevision;
			DestinationConnectionRevision = destinationConnectionRevision;
		}
	}
	public sealed class PortalPath
	{
		private readonly List<PortalPathStep> _steps = new List<PortalPathStep>();

		public int MaxTraversals { get; }

		public int Count => _steps.Count;

		public float LogicalDistance { get; private set; }

		public IReadOnlyList<PortalPathStep> Steps => _steps;

		public string Signature
		{
			get
			{
				if (_steps.Count == 0)
				{
					return "root";
				}
				string text = string.Empty;
				for (int i = 0; i < _steps.Count; i++)
				{
					PortalPathStep portalPathStep = _steps[i];
					text = text + ((i == 0) ? string.Empty : "/") + portalPathStep.Transform.SourcePortalId + ">" + portalPathStep.Transform.DestinationPortalId + ":" + portalPathStep.SourceConnectionRevision + ":" + portalPathStep.DestinationConnectionRevision;
				}
				return text;
			}
		}

		public PortalPath(int maxTraversals = 8)
		{
			if (maxTraversals < 1)
			{
				throw new ArgumentOutOfRangeException("maxTraversals");
			}
			MaxTraversals = maxTraversals;
		}

		public bool TryAppend(Portal source, Portal destination, float distanceBeforeCrossing = 0f)
		{
			if (_steps.Count >= MaxTraversals || !source.IsLinked || source.Pair != destination)
			{
				return false;
			}
			_steps.Add(new PortalPathStep(new PortalTransform(source.Id, destination.Id, source.Pose, destination.Pose), source.ConnectionRevision, destination.ConnectionRevision));
			LogicalDistance += Math.Max(0f, distanceBeforeCrossing);
			return true;
		}

		public void AddLogicalDistance(float distance)
		{
			LogicalDistance += Math.Max(0f, distance);
		}

		public Vector3 TransformPoint(Vector3 point)
		{
			for (int i = 0; i < _steps.Count; i++)
			{
				point = _steps[i].Transform.TransformPoint(point);
			}
			return point;
		}

		public Vector3 TransformDirection(Vector3 direction)
		{
			for (int i = 0; i < _steps.Count; i++)
			{
				direction = _steps[i].Transform.TransformDirection(direction);
			}
			return direction;
		}

		public PortalRay TransformRay(PortalRay ray)
		{
			for (int i = 0; i < _steps.Count; i++)
			{
				ray = _steps[i].Transform.TransformRay(ray);
			}
			return ray;
		}

		public bool HasCurrentRevisions()
		{
			for (int i = 0; i < _steps.Count; i++)
			{
				if (_steps[i].Transform.SourcePortalId == null)
				{
					return false;
				}
			}
			return true;
		}
	}
	public readonly struct PortalPose
	{
		public Vector3 Position { get; }

		public Quaternion Rotation { get; }

		public Vector3 Scale { get; }

		public static PortalPose Identity => new PortalPose(Vector3.Zero, Quaternion.Identity, Vector3.One);

		public PortalPose(Vector3 position, Quaternion rotation)
			: this(position, rotation, Vector3.One)
		{
		}

		public PortalPose(Vector3 position, Quaternion rotation, Vector3 scale)
		{
			Position = position;
			Rotation = Quaternion.Normalize(rotation);
			Scale = scale;
		}

		public bool HasFiniteValues()
		{
			if (IsFinite(Position) && IsFinite(Scale) && IsFinite(Rotation.X) && IsFinite(Rotation.Y) && IsFinite(Rotation.Z) && IsFinite(Rotation.W) && Scale.X != 0f && Scale.Y != 0f)
			{
				return Scale.Z != 0f;
			}
			return false;
		}

		public bool HasUniformUnitScale(float tolerance = 0.0001f)
		{
			if (Math.Abs(Scale.X - 1f) <= tolerance && Math.Abs(Scale.Y - 1f) <= tolerance)
			{
				return Math.Abs(Scale.Z - 1f) <= tolerance;
			}
			return false;
		}

		public Vector3 ToLocalPoint(Vector3 worldPoint)
		{
			Vector3 vector = Vector3.Transform(worldPoint - Position, Quaternion.Inverse(Rotation));
			return new Vector3(vector.X / Scale.X, vector.Y / Scale.Y, vector.Z / Scale.Z);
		}

		public Vector3 ToWorldPoint(Vector3 localPoint)
		{
			Vector3 value = new Vector3(localPoint.X * Scale.X, localPoint.Y * Scale.Y, localPoint.Z * Scale.Z);
			return Position + Vector3.Transform(value, Rotation);
		}

		public Vector3 ToLocalDirection(Vector3 worldDirection)
		{
			return Vector3.Transform(worldDirection, Quaternion.Inverse(Rotation));
		}

		public Vector3 ToWorldDirection(Vector3 localDirection)
		{
			return Vector3.Transform(localDirection, Rotation);
		}

		private static bool IsFinite(Vector3 value)
		{
			if (IsFinite(value.X) && IsFinite(value.Y))
			{
				return IsFinite(value.Z);
			}
			return false;
		}

		private static bool IsFinite(float value)
		{
			if (!float.IsNaN(value))
			{
				return !float.IsInfinity(value);
			}
			return false;
		}
	}
	public readonly struct PortalRay
	{
		public Vector3 Origin { get; }

		public Vector3 Direction { get; }

		public PortalRay(Vector3 origin, Vector3 direction)
		{
			Origin = origin;
			Direction = ((direction.LengthSquared() > 0f) ? Vector3.Normalize(direction) : Vector3.Zero);
		}

		public Vector3 GetPoint(float distance)
		{
			return Origin + Direction * distance;
		}
	}
	public readonly struct PortalPlane
	{
		public Vector3 Normal { get; }

		public float Distance { get; }

		public PortalPlane(Vector3 normal, float distance)
		{
			float num = normal.Length();
			if (num <= 0f)
			{
				throw new ArgumentException("A portal plane needs a non-zero normal.", "normal");
			}
			Normal = normal / num;
			Distance = distance / num;
		}

		public float SignedDistanceTo(Vector3 point)
		{
			return Vector3.Dot(Normal, point) + Distance;
		}
	}
	public readonly struct PortalBounds
	{
		public Vector3 Center { get; }

		public Vector3 Extents { get; }

		public PortalBounds(Vector3 center, Vector3 extents)
		{
			if (extents.X < 0f || extents.Y < 0f || extents.Z < 0f)
			{
				throw new ArgumentOutOfRangeException("extents", "Bounds extents cannot be negative.");
			}
			Center = center;
			Extents = extents;
		}
	}
	public struct PortalTravellerState
	{
		public Vector3 Position;

		public Quaternion Rotation;

		public Vector3 Velocity;

		public Vector3 AngularVelocity;

		public PortalTravellerState(Vector3 position, Quaternion rotation, Vector3 velocity, Vector3 angularVelocity)
		{
			Position = position;
			Rotation = Quaternion.Normalize(rotation);
			Velocity = velocity;
			AngularVelocity = angularVelocity;
		}
	}
	public readonly struct PortalTransform
	{
		private static readonly Quaternion HalfTurn = Quaternion.CreateFromAxisAngle(Vector3.UnitY, MathF.PI);

		public string SourcePortalId { get; }

		public string DestinationPortalId { get; }

		public PortalPose Source { get; }

		public PortalPose Destination { get; }

		public Quaternion Rotation { get; }

		public PortalTransform(string sourcePortalId, string destinationPortalId, PortalPose source, PortalPose destination)
		{
			if (string.IsNullOrWhiteSpace(sourcePortalId))
			{
				throw new ArgumentException("A source portal id is required.", "sourcePortalId");
			}
			if (string.IsNullOrWhiteSpace(destinationPortalId))
			{
				throw new ArgumentException("A destination portal id is required.", "destinationPortalId");
			}
			if (!source.HasFiniteValues() || !destination.HasFiniteValues())
			{
				throw new ArgumentException("Portal poses must contain finite, non-zero values.");
			}
			SourcePortalId = sourcePortalId;
			DestinationPortalId = destinationPortalId;
			Source = source;
			Destination = destination;
			Rotation = Quaternion.Normalize(destination.Rotation * HalfTurn * Quaternion.Inverse(source.Rotation));
		}

		public Vector3 TransformPoint(Vector3 worldPoint)
		{
			Vector3 vector = Source.ToLocalPoint(worldPoint);
			Vector3 localPoint = new Vector3(0f - vector.X, vector.Y, 0f - vector.Z);
			return Destination.ToWorldPoint(localPoint);
		}

		public Vector3 TransformDirection(Vector3 worldDirection)
		{
			return Vector3.Transform(worldDirection, Rotation);
		}

		public Quaternion TransformRotation(Quaternion worldRotation)
		{
			return Quaternion.Normalize(Rotation * worldRotation);
		}

		public PortalTravellerState TransformState(PortalTravellerState state)
		{
			return new PortalTravellerState(TransformPoint(state.Position), TransformRotation(state.Rotation), TransformDirection(state.Velocity), TransformDirection(state.AngularVelocity));
		}

		public PortalRay TransformRay(PortalRay ray)
		{
			return new PortalRay(TransformPoint(ray.Origin), TransformDirection(ray.Direction));
		}

		public PortalPlane TransformPlane(PortalPlane plane)
		{
			Vector3 worldPoint = plane.Normal * (0f - plane.Distance);
			Vector3 right = TransformPoint(worldPoint);
			Vector3 vector = Vector3.Normalize(TransformDirection(plane.Normal));
			return new PortalPlane(vector, 0f - Vector3.Dot(vector, right));
		}

		public Vector3 TransformNormal(Vector3 worldNormal)
		{
			return Vector3.Normalize(TransformDirection(worldNormal));
		}

		public int TransformSide(int sourceSide)
		{
			if (sourceSide == 0)
			{
				return 0;
			}
			return -Math.Sign(sourceSide);
		}

		public override string ToString()
		{
			return SourcePortalId + "->" + DestinationPortalId;
		}
	}
}
namespace Ravengates.Configuration
{
	public enum PortalFallbackMode
	{
		Block,
		UnstableEffect,
		VanillaTeleport
	}
	public sealed class PortalConfiguration
	{
		public bool PortalRenderEnabled { get; set; } = true;

		public bool EnablePlayerTraversal { get; set; } = true;

		public int MaxRecursionDepth { get; set; } = 2;

		public int MaxPortalRenderPassesPerFrame { get; set; } = 6;

		public float PortalRenderScale { get; set; } = 0.75f;

		public float MaxPortalViewDistance { get; set; } = 400f;

		public float MinPortalScreenPixels { get; set; } = 64f;

		public int RenderZoneRadius { get; set; } = 1;

		public int InteractiveZoneRadius { get; set; } = 2;

		public int CrossingReadyZoneRadius { get; set; } = 3;

		public double RemoteUnloadGraceSeconds { get; set; } = 10.0;

		public int MaxRemoteInterestRegionsPerPlayer { get; set; } = 4;

		public int MaxRemoteZonesPerPlayer { get; set; } = 98;

		public float PortalInterestActivationDistance { get; set; } = 128f;

		public int MaxCrossingsPerFixedStep { get; set; } = 8;

		public float PortalPlaneEpsilon { get; set; } = 0.02f;

		public bool EnableVisualStraddling { get; set; } = true;

		public bool EnableRemoteProxyCollision { get; set; }

		public bool RespectVanillaPortalRestrictions { get; set; } = true;

		public bool AllowInteractionThroughPortal { get; set; }

		public bool AllowAITraversal { get; set; }

		public bool ServerAuthoritativeTraversal { get; set; } = true;

		public bool ClientPrediction { get; set; } = true;

		public int MaxRemoteSimulatedCharacters { get; set; } = 50;

		public PortalFallbackMode FallbackMode { get; set; }

		public void Validate()
		{
			MaxRecursionDepth = Clamp(MaxRecursionDepth, 0, 5);
			MaxPortalRenderPassesPerFrame = Clamp(MaxPortalRenderPassesPerFrame, 0, 16);
			PortalRenderScale = ClampFinite(PortalRenderScale, 0.25f, 1f, 0.75f);
			MaxPortalViewDistance = ClampFinite(MaxPortalViewDistance, 50f, 1000f, 400f);
			MinPortalScreenPixels = ClampFinite(MinPortalScreenPixels, 0f, 512f, 64f);
			RenderZoneRadius = Clamp(RenderZoneRadius, 0, 6);
			InteractiveZoneRadius = Clamp(InteractiveZoneRadius, 0, 6);
			CrossingReadyZoneRadius = Clamp(CrossingReadyZoneRadius, 0, 6);
			if (InteractiveZoneRadius < RenderZoneRadius)
			{
				InteractiveZoneRadius = RenderZoneRadius;
			}
			if (CrossingReadyZoneRadius < InteractiveZoneRadius)
			{
				CrossingReadyZoneRadius = InteractiveZoneRadius;
			}
			RemoteUnloadGraceSeconds = ClampFinite(RemoteUnloadGraceSeconds, 0.0, 60.0, 10.0);
			MaxRemoteInterestRegionsPerPlayer = Clamp(MaxRemoteInterestRegionsPerPlayer, 1, 32);
			MaxRemoteZonesPerPlayer = Clamp(MaxRemoteZonesPerPlayer, 1, 512);
			PortalInterestActivationDistance = ClampFinite(PortalInterestActivationDistance, 0f, 512f, 128f);
			MaxCrossingsPerFixedStep = Clamp(MaxCrossingsPerFixedStep, 1, 32);
			PortalPlaneEpsilon = ClampFinite(PortalPlaneEpsilon, 0f, 0.25f, 0.02f);
			MaxRemoteSimulatedCharacters = Clamp(MaxRemoteSimulatedCharacters, 0, 500);
		}

		private static int Clamp(int value, int min, int max)
		{
			return Math.Max(min, Math.Min(max, value));
		}

		private static float ClampFinite(float value, float min, float max, float fallback)
		{
			if (!float.IsNaN(value) && !float.IsInfinity(value))
			{
				return Math.Max(min, Math.Min(max, value));
			}
			return fallback;
		}

		private static double ClampFinite(double value, double min, double max, double fallback)
		{
			if (!double.IsNaN(value) && !double.IsInfinity(value))
			{
				return Math.Max(min, Math.Min(max, value));
			}
			return fallback;
		}
	}
}