using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security.Cryptography;
using System.Text;
using System.Threading;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = "")]
[assembly: AssemblyCompany("Valayer.Core")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.1.8.0")]
[assembly: AssemblyInformationalVersion("1.1.8")]
[assembly: AssemblyProduct("Valayer.Core")]
[assembly: AssemblyTitle("Valayer.Core")]
[assembly: AssemblyVersion("1.1.8.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace Valayer.Core
{
	internal sealed class CoreConfig
	{
		internal ConfigEntry<bool> Enabled { get; private set; }

		internal ConfigEntry<bool> DiagnosticsEnabled { get; private set; }

		internal ConfigEntry<bool> HarmonyInventoryEnabled { get; private set; }

		internal ConfigEntry<bool> WriteJsonReports { get; private set; }

		internal ConfigEntry<float> SlowCallThresholdMs { get; private set; }

		internal ConfigEntry<float> OperationTailSeconds { get; private set; }

		internal ConfigEntry<int> DiagnosticMaximumSessions { get; private set; }

		internal ConfigEntry<int> DiagnosticMaximumOperationReports { get; private set; }

		internal ConfigEntry<bool> ExperimentalDestructionCoordination { get; private set; }

		internal ConfigEntry<bool> DetailedDestructionDiagnostics { get; private set; }

		internal ConfigEntry<bool> ExperimentalDestructionIdentityTracking { get; private set; }

		internal ConfigEntry<bool> ExperimentalDestructionSpatialTracing { get; private set; }

		internal ConfigEntry<int> DestructionMaximumSpatialGroups { get; private set; }

		internal ConfigEntry<int> DestructionMaximumTrackedEvents { get; private set; }

		internal static CoreConfig Bind(ConfigFile config)
		{
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Expected O, but got Unknown
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Expected O, but got Unknown
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: Expected O, but got Unknown
			//IL_013b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0145: Expected O, but got Unknown
			//IL_01e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ea: Expected O, but got Unknown
			//IL_0215: Unknown result type (might be due to invalid IL or missing references)
			//IL_021f: Expected O, but got Unknown
			return new CoreConfig
			{
				Enabled = config.Bind<bool>("General", "Enabled", true, "Master switch for general-purpose Valayer infrastructure."),
				DiagnosticsEnabled = config.Bind<bool>("Diagnostics", "Enabled", true, "Measure registered destruction operations without changing gameplay results."),
				HarmonyInventoryEnabled = config.Bind<bool>("Diagnostics", "HarmonyPatchInventory", true, "Record relevant live Harmony owners and patch methods after startup."),
				WriteJsonReports = config.Bind<bool>("Diagnostics", "WriteJsonReports", true, "Write machine-readable reports to Valayer's per-user application-data directory, outside the r2modman profile."),
				SlowCallThresholdMs = config.Bind<float>("Diagnostics", "SlowCallThresholdMs", 4f, new ConfigDescription("Log individual registered calls at or above this duration.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.1f, 1000f), Array.Empty<object>())),
				OperationTailSeconds = config.Bind<float>("Diagnostics", "OperationTailSeconds", 2f, new ConfigDescription("Continue attributing asynchronous work after an operation root completes.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 10f), Array.Empty<object>())),
				DiagnosticMaximumSessions = config.Bind<int>("Diagnostics", "MaximumSessions", 8, new ConfigDescription("Maximum retained Valayer diagnostic sessions per profile.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 64), Array.Empty<object>())),
				DiagnosticMaximumOperationReports = config.Bind<int>("Diagnostics", "MaximumOperationReportsPerSession", 256, new ConfigDescription("Maximum retained operation reports in the current diagnostic session.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 10000), Array.Empty<object>())),
				ExperimentalDestructionCoordination = config.Bind<bool>("Destruction", "ExperimentalDestructionCoordination", false, "EXPERIMENTAL and disabled by default: enable the operation-scoped Core realization coordinator. It does not alter authoritative gameplay when disabled."),
				DetailedDestructionDiagnostics = config.Bind<bool>("Diagnostics", "DetailedDestructionDiagnostics", false, "EXPERIMENTAL and disabled by default: collect operation-wide destruction realization metrics."),
				ExperimentalDestructionIdentityTracking = config.Bind<bool>("Diagnostics", "ExperimentalDestructionIdentityTracking", false, "EXPERIMENTAL and disabled by default: trace per-object destruction identities."),
				ExperimentalDestructionSpatialTracing = config.Bind<bool>("Diagnostics", "ExperimentalDestructionSpatialTracing", false, "EXPERIMENTAL and disabled by default: trace destruction spatial footprints."),
				DestructionMaximumSpatialGroups = config.Bind<int>("Destruction", "MaximumSpatialGroups", 256, new ConfigDescription("Bound for experimental destruction spatial groups.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 4096), Array.Empty<object>())),
				DestructionMaximumTrackedEvents = config.Bind<int>("Destruction", "MaximumTrackedEvents", 4096, new ConfigDescription("Bound for experimental destruction realization events.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 100000), Array.Empty<object>()))
			};
		}

		internal void LogEffective(ManualLogSource log)
		{
			log.LogInfo((object)("Effective core config: Enabled=" + Enabled.Value + ", Diagnostics=" + DiagnosticsEnabled.Value + ", HarmonyInventory=" + HarmonyInventoryEnabled.Value + ", JsonReports=" + WriteJsonReports.Value + ", SlowCallMs=" + SlowCallThresholdMs.Value.ToString("0.###") + ", TailSeconds=" + OperationTailSeconds.Value.ToString("0.###") + ", DestructionCoordination(experimental)=" + ExperimentalDestructionCoordination.Value + ", DetailedDestructionDiagnostics=" + DetailedDestructionDiagnostics.Value + ", IdentityTracing=" + ExperimentalDestructionIdentityTracking.Value + ", SpatialTracing=" + ExperimentalDestructionSpatialTracing.Value + "."));
		}
	}
	public static class DestructionRealizationCoordinator
	{
		public struct Summary
		{
			public int VisualEligible;

			public int VisualRealized;

			public int VisualGroups;

			public int AudioEligible;

			public int AudioRealized;

			public int AudioGroups;

			public int YieldEligible;

			public int YieldRealized;

			public int FootprintEvents;

			public float MaximumDistance;
		}

		private sealed class State
		{
			internal int OperationId;

			internal readonly HashSet<long> VisualCells = new HashSet<long>();

			internal readonly HashSet<long> AudioCells = new HashSet<long>();

			internal int VisualEligible;

			internal int VisualRealized;

			internal int AudioEligible;

			internal int AudioRealized;

			internal int YieldEligible;

			internal int YieldRealized;

			internal int FootprintEvents;

			internal float MaximumDistance;
		}

		private static readonly object Gate = new object();

		private static bool _enabled;

		private static int _maximumCells = 256;

		private static int _maximumEvents = 4096;

		private static int _nextOperation;

		private static State _current;

		public static bool Enabled
		{
			get
			{
				lock (Gate)
				{
					return _enabled;
				}
			}
		}

		internal static void Initialize(bool enabled, int maximumCells, int maximumEvents)
		{
			lock (Gate)
			{
				_enabled = enabled;
				_maximumCells = Math.Max(1, Math.Min(4096, maximumCells));
				_maximumEvents = Math.Max(1, Math.Min(100000, maximumEvents));
				_current = null;
			}
		}

		public static int Begin(string owner)
		{
			lock (Gate)
			{
				if (!_enabled || _current != null)
				{
					return 0;
				}
				_current = new State();
				_current.OperationId = ++_nextOperation;
				return _current.OperationId;
			}
		}

		public static void RecordVisual(float x, float y, float z, bool realized)
		{
			lock (Gate)
			{
				if (_enabled && _current != null && _current.VisualEligible + _current.AudioEligible < _maximumEvents)
				{
					_current.VisualEligible++;
					if (realized)
					{
						_current.VisualRealized++;
					}
					AddCell(_current.VisualCells, x, y, z);
					UpdateDistance(_current, x, y, z);
				}
			}
		}

		public static void RecordAudio(float x, float y, float z, bool realized)
		{
			lock (Gate)
			{
				if (_enabled && _current != null && _current.VisualEligible + _current.AudioEligible < _maximumEvents)
				{
					_current.AudioEligible++;
					if (realized)
					{
						_current.AudioRealized++;
					}
					AddCell(_current.AudioCells, x, y, z);
					UpdateDistance(_current, x, y, z);
				}
			}
		}

		public static void RecordYield(int eligible, int realized)
		{
			lock (Gate)
			{
				if (_enabled && _current != null)
				{
					_current.YieldEligible = Math.Min(_maximumEvents, _current.YieldEligible + Math.Max(0, eligible));
					_current.YieldRealized = Math.Min(_maximumEvents, _current.YieldRealized + Math.Max(0, realized));
				}
			}
		}

		public static void RecordFootprint(float x, float y, float z)
		{
			lock (Gate)
			{
				if (_enabled && _current != null && _current.FootprintEvents < _maximumEvents)
				{
					_current.FootprintEvents++;
					UpdateDistance(_current, x, y, z);
				}
			}
		}

		public static Summary End(int operationId)
		{
			lock (Gate)
			{
				if (!_enabled || operationId == 0 || _current == null || _current.OperationId != operationId)
				{
					return default(Summary);
				}
				State current = _current;
				_current = null;
				return new Summary
				{
					VisualEligible = current.VisualEligible,
					VisualRealized = current.VisualRealized,
					VisualGroups = current.VisualCells.Count,
					AudioEligible = current.AudioEligible,
					AudioRealized = current.AudioRealized,
					AudioGroups = current.AudioCells.Count,
					YieldEligible = current.YieldEligible,
					YieldRealized = current.YieldRealized,
					FootprintEvents = current.FootprintEvents,
					MaximumDistance = current.MaximumDistance
				};
			}
		}

		internal static void Shutdown()
		{
			lock (Gate)
			{
				_current = null;
			}
		}

		private static void AddCell(HashSet<long> cells, float x, float y, float z)
		{
			if (cells.Count < _maximumCells)
			{
				int num = (int)Math.Floor(x / 3f);
				int num2 = (int)Math.Floor(y / 3f);
				int num3 = (int)Math.Floor(z / 3f);
				long item = ((long)num * 73856093L) ^ ((long)num2 * 19349663L) ^ ((long)num3 * 83492791L);
				cells.Add(item);
			}
		}

		private static void UpdateDistance(State state, float x, float y, float z)
		{
			float num = x * x + y * y + z * z;
			float num2 = state.MaximumDistance * state.MaximumDistance;
			if (num > num2)
			{
				state.MaximumDistance = (float)Math.Sqrt(num);
			}
		}
	}
	internal static class DiagnosticFiles
	{
		internal sealed class MetricRecord
		{
			internal readonly string Name;

			internal readonly long Calls;

			internal readonly double TotalMs;

			internal readonly double MaxMs;

			internal MetricRecord(string name, long calls, double totalMs, double maxMs)
			{
				Name = name;
				Calls = calls;
				TotalMs = totalMs;
				MaxMs = maxMs;
			}
		}

		internal sealed class PatchRecord
		{
			internal readonly string Target;

			internal readonly string[] Owners;

			internal readonly string[] Prefixes;

			internal readonly string[] Postfixes;

			internal readonly string[] Transpilers;

			internal readonly string[] Finalizers;

			internal PatchRecord(string target, string[] owners, string[] prefixes, string[] postfixes, string[] transpilers, string[] finalizers)
			{
				Target = target;
				Owners = owners;
				Prefixes = prefixes;
				Postfixes = postfixes;
				Transpilers = transpilers;
				Finalizers = finalizers;
			}
		}

		internal static void WriteOperation(int id, string kind, double rootMs, string error, string reason, IEnumerable<MetricRecord> metrics)
		{
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.Append("{\n  \"schema\": 1,\n  \"kind\": \"operation-diagnostics\",");
			stringBuilder.Append("\n  \"operationId\": ").Append(id).Append(',');
			stringBuilder.Append("\n  \"operationKind\": ").Append(Quote(kind)).Append(',');
			stringBuilder.Append("\n  \"rootDurationMs\": ").Append(Number(rootMs)).Append(',');
			stringBuilder.Append("\n  \"reason\": ").Append(Quote(reason)).Append(',');
			stringBuilder.Append("\n  \"error\": ").Append((error == null) ? "null" : Quote(error)).Append(',');
			stringBuilder.Append("\n  \"metrics\": [");
			bool flag = true;
			foreach (MetricRecord metric in metrics)
			{
				if (!flag)
				{
					stringBuilder.Append(',');
				}
				flag = false;
				stringBuilder.Append("\n    {\"name\": ").Append(Quote(metric.Name)).Append(", \"calls\": ")
					.Append(metric.Calls)
					.Append(", \"totalMs\": ")
					.Append(Number(metric.TotalMs))
					.Append(", \"maxMs\": ")
					.Append(Number(metric.MaxMs))
					.Append('}');
			}
			stringBuilder.Append("\n  ]\n}\n");
			Write("operation-" + id.ToString("0000", CultureInfo.InvariantCulture) + ".json", stringBuilder.ToString());
		}

		internal static void WriteHarmonyInventory(IEnumerable<PatchRecord> records)
		{
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.Append("{\n  \"schema\": 1,\n  \"kind\": \"harmony-inventory\",\n  \"records\": [");
			bool flag = true;
			foreach (PatchRecord record in records)
			{
				if (!flag)
				{
					stringBuilder.Append(',');
				}
				flag = false;
				stringBuilder.Append("\n    {\"target\": ").Append(Quote(record.Target)).Append(", \"owners\": ")
					.Append(Array(record.Owners))
					.Append(", \"prefixes\": ")
					.Append(Array(record.Prefixes))
					.Append(", \"postfixes\": ")
					.Append(Array(record.Postfixes))
					.Append(", \"transpilers\": ")
					.Append(Array(record.Transpilers))
					.Append(", \"finalizers\": ")
					.Append(Array(record.Finalizers))
					.Append('}');
			}
			stringBuilder.Append("\n  ]\n}\n");
			Write("harmony-inventory.json", stringBuilder.ToString());
		}

		private static void Write(string name, string contents)
		{
			try
			{
				DiagnosticStorage.WriteText(name, contents);
			}
			catch (Exception ex)
			{
				Plugin.Log.LogError((object)("Could not write diagnostic report " + name + ": " + ex));
			}
		}

		private static string Array(IEnumerable<string> values)
		{
			return "[" + string.Join(", ", values.Select(Quote).ToArray()) + "]";
		}

		private static string Number(double value)
		{
			return value.ToString("0.######", CultureInfo.InvariantCulture);
		}

		private static string Quote(string value)
		{
			if (value == null)
			{
				return "null";
			}
			return "\"" + value.Replace("\\", "\\\\").Replace("\"", "\\\"").Replace("\r", "\\r")
				.Replace("\n", "\\n") + "\"";
		}
	}
	public static class DiagnosticStorage
	{
		private sealed class WriteRequest
		{
			internal readonly string Name;

			internal readonly string Contents;

			internal WriteRequest(string name, string contents)
			{
				Name = name;
				Contents = contents;
			}
		}

		private static readonly object Gate = new object();

		private static readonly ConcurrentQueue<WriteRequest> Queue = new ConcurrentQueue<WriteRequest>();

		private static readonly AutoResetEvent Wake = new AutoResetEvent(initialState: false);

		private static ManualLogSource _log;

		private static Thread _worker;

		private static volatile bool _stopping;

		private static string _sessionDirectory;

		private static int _maximumSessions;

		private static int _maximumOperationReports;

		public static string SessionDirectory
		{
			get
			{
				lock (Gate)
				{
					return _sessionDirectory;
				}
			}
		}

		internal static void Initialize(ManualLogSource log, int maximumSessions, int maximumOperationReports)
		{
			lock (Gate)
			{
				if (_worker == null)
				{
					_log = log;
					_maximumSessions = Math.Max(1, Math.Min(64, maximumSessions));
					_maximumOperationReports = Math.Max(1, Math.Min(10000, maximumOperationReports));
					string profile = ProfileDirectory();
					string text = Path.Combine(ApplicationRoot(), "profiles", ProfileIdentity(profile));
					Directory.CreateDirectory(text);
					MigrateLegacy(profile, text);
					string path = "session-" + DateTime.UtcNow.ToString("yyyyMMdd-HHmmssfff", CultureInfo.InvariantCulture) + "-" + Guid.NewGuid().ToString("N").Substring(0, 8);
					_sessionDirectory = Path.Combine(text, path);
					Directory.CreateDirectory(_sessionDirectory);
					ApplyRetention(text);
					_stopping = false;
					_worker = new Thread(WorkerLoop)
					{
						IsBackground = true,
						Name = "Valayer-DiagnosticStorage"
					};
					_worker.Start();
					if (_log != null)
					{
						_log.LogInfo((object)("Valayer diagnostics stored outside the profile at: " + _sessionDirectory));
					}
				}
			}
		}

		public static void WriteText(string fileName, string contents)
		{
			if (string.IsNullOrWhiteSpace(fileName) || contents == null)
			{
				return;
			}
			string fileName2 = Path.GetFileName(fileName);
			if (!string.Equals(fileName2, fileName, StringComparison.Ordinal) || fileName2.Length == 0)
			{
				return;
			}
			lock (Gate)
			{
				if (_worker == null || _stopping || string.IsNullOrEmpty(_sessionDirectory))
				{
					return;
				}
				Queue.Enqueue(new WriteRequest(fileName2, contents));
			}
			Wake.Set();
		}

		public static string ReadText(string fileName)
		{
			if (string.IsNullOrWhiteSpace(fileName) || Path.GetFileName(fileName) != fileName)
			{
				return null;
			}
			string path;
			lock (Gate)
			{
				if (string.IsNullOrEmpty(_sessionDirectory))
				{
					return null;
				}
				path = Path.Combine(_sessionDirectory, fileName);
			}
			try
			{
				return File.Exists(path) ? File.ReadAllText(path) : null;
			}
			catch
			{
				return null;
			}
		}

		internal static void Shutdown()
		{
			Thread worker;
			lock (Gate)
			{
				worker = _worker;
				if (worker == null)
				{
					return;
				}
				_stopping = true;
			}
			Wake.Set();
			if (worker != Thread.CurrentThread)
			{
				worker.Join(2000);
			}
			lock (Gate)
			{
				_worker = null;
			}
		}

		private static void WorkerLoop()
		{
			while (true)
			{
				if (Queue.TryDequeue(out var result))
				{
					WriteOne(result);
					continue;
				}
				if (_stopping && Queue.IsEmpty)
				{
					break;
				}
				Wake.WaitOne(250);
			}
		}

		private static void WriteOne(WriteRequest request)
		{
			try
			{
				string sessionDirectory;
				lock (Gate)
				{
					sessionDirectory = _sessionDirectory;
				}
				if (!string.IsNullOrEmpty(sessionDirectory))
				{
					Directory.CreateDirectory(sessionDirectory);
					string text = Path.Combine(sessionDirectory, request.Name);
					string text2 = text + ".writing-" + Guid.NewGuid().ToString("N");
					File.WriteAllText(text2, request.Contents, new UTF8Encoding(encoderShouldEmitUTF8Identifier: false));
					if (File.Exists(text))
					{
						File.Delete(text);
					}
					File.Move(text2, text);
					if (_log != null)
					{
						_log.LogInfo((object)("Wrote diagnostic report: " + text));
					}
					if (request.Name.StartsWith("operation-", StringComparison.OrdinalIgnoreCase))
					{
						ApplyOperationRetention(sessionDirectory);
					}
				}
			}
			catch (Exception ex)
			{
				if (_log != null)
				{
					_log.LogError((object)("Could not write diagnostic report " + request.Name + ": " + ex));
				}
			}
		}

		private static void MigrateLegacy(string profile, string profileDirectory)
		{
			string[] array = new string[2]
			{
				Path.Combine(profile, "BepInEx", "diagnostics", "foundation.valayer.heimordination"),
				Path.Combine(profile, "BepInEx", "diagnostics", "foundation.valayer.heimordination.superviking")
			};
			string[] array2 = array.Where(Directory.Exists).SelectMany((string path2) => Directory.GetFiles(path2, "*", SearchOption.AllDirectories)).ToArray();
			if (array2.Length == 0)
			{
				return;
			}
			string text = Path.Combine(profileDirectory, "migrated-" + DateTime.UtcNow.ToString("yyyyMMdd-HHmmssfff", CultureInfo.InvariantCulture));
			Directory.CreateDirectory(text);
			int num = 0;
			string[] array3 = array2;
			foreach (string text2 in array3)
			{
				try
				{
					string fileName = Path.GetFileName(text2);
					string text3 = Path.Combine(text, fileName);
					if (File.Exists(text3))
					{
						text3 = Path.Combine(text, Path.GetFileNameWithoutExtension(fileName) + "-" + num + Path.GetExtension(fileName));
					}
					File.Copy(text2, text3, overwrite: false);
					if (File.Exists(text3) && new FileInfo(text3).Length == new FileInfo(text2).Length)
					{
						File.Delete(text2);
						num++;
					}
				}
				catch (Exception ex)
				{
					if (_log != null)
					{
						_log.LogWarning((object)("Could not migrate Valayer diagnostic " + text2 + ": " + ex.Message));
					}
				}
			}
			array3 = array;
			foreach (string path in array3)
			{
				try
				{
					if (Directory.Exists(path) && !Directory.EnumerateFileSystemEntries(path).Any())
					{
						Directory.Delete(path);
					}
				}
				catch
				{
				}
			}
			if (_log != null)
			{
				_log.LogInfo((object)("Migrated " + num + " Valayer diagnostic files from the profile into " + text + "."));
			}
		}

		private static void ApplyRetention(string profileDirectory)
		{
			try
			{
				DirectoryInfo[] source = (from item in new DirectoryInfo(profileDirectory).GetDirectories()
					orderby item.LastWriteTimeUtc descending
					select item).ToArray();
				foreach (DirectoryInfo item in source.Skip(_maximumSessions))
				{
					try
					{
						item.Delete(recursive: true);
					}
					catch (Exception ex)
					{
						if (_log != null)
						{
							_log.LogWarning((object)("Could not prune diagnostic session " + item.FullName + ": " + ex.Message));
						}
					}
				}
				DirectoryInfo directoryInfo = source.FirstOrDefault((DirectoryInfo item) => item.FullName == _sessionDirectory);
				if (directoryInfo != null)
				{
					ApplyOperationRetention(directoryInfo.FullName);
				}
			}
			catch (Exception ex2)
			{
				if (_log != null)
				{
					_log.LogWarning((object)("Could not apply diagnostic session retention: " + ex2.Message));
				}
			}
		}

		private static void ApplyOperationRetention(string directory)
		{
			try
			{
				foreach (FileInfo item in (from item in new DirectoryInfo(directory).GetFiles("operation-*.json")
					orderby item.LastWriteTimeUtc descending
					select item).ToArray().Skip(_maximumOperationReports))
				{
					try
					{
						item.Delete();
					}
					catch
					{
					}
				}
			}
			catch
			{
			}
		}

		private static string ProfileDirectory()
		{
			string fullPath = Path.GetFullPath(Paths.ConfigPath);
			DirectoryInfo directoryInfo = new DirectoryInfo(fullPath);
			if (directoryInfo.Parent == null || directoryInfo.Parent.Parent == null)
			{
				return fullPath;
			}
			return directoryInfo.Parent.Parent.FullName;
		}

		private static string ApplicationRoot()
		{
			string text = Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData);
			if (string.IsNullOrEmpty(text))
			{
				text = Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData);
			}
			if (string.IsNullOrEmpty(text))
			{
				text = Path.Combine(Path.GetTempPath(), "Valayer");
			}
			return Path.Combine(text, "Valayer", "Heimordination");
		}

		private static string ProfileIdentity(string profile)
		{
			using SHA256 sHA = SHA256.Create();
			return BitConverter.ToString(sHA.ComputeHash(Encoding.UTF8.GetBytes(profile.TrimEnd(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar).ToUpperInvariant()))).Replace("-", string.Empty).Substring(0, 20)
				.ToLowerInvariant();
		}
	}
	internal static class HarmonyInventory
	{
		private static readonly string[] RelevantTypes = new string[14]
		{
			"MineRock", "MineRock5", "TreeBase", "TreeLog", "Destructible", "TerrainComp", "Heightmap", "ItemDrop", "EffectList", "ZNetView",
			"ZRoutedRpc", "Player", "Character", "Game"
		};

		internal static void Write(ManualLogSource log, bool writeJson)
		{
			if (!Plugin.Settings.HarmonyInventoryEnabled.Value)
			{
				return;
			}
			List<DiagnosticFiles.PatchRecord> list = new List<DiagnosticFiles.PatchRecord>();
			foreach (MethodBase item in Harmony.GetAllPatchedMethods().OrderBy(Describe))
			{
				Patches patchInfo = Harmony.GetPatchInfo(item);
				if (patchInfo == null)
				{
					continue;
				}
				string text = ((item.DeclaringType == null) ? string.Empty : item.DeclaringType.FullName);
				if (RelevantTypes.Contains(text) || text.StartsWith("SuperViking.", StringComparison.Ordinal) || text.StartsWith("Valayer.", StringComparison.Ordinal) || patchInfo.Owners.Any((string owner) => owner.StartsWith("foundation.valayer.", StringComparison.Ordinal)))
				{
					list.Add(new DiagnosticFiles.PatchRecord(Describe(item), patchInfo.Owners.OrderBy((string owner) => owner).ToArray(), DescribePatches(patchInfo.Prefixes), DescribePatches(patchInfo.Postfixes), DescribePatches(patchInfo.Transpilers), DescribePatches(patchInfo.Finalizers)));
				}
			}
			log.LogInfo((object)("Harmony inventory captured " + list.Count + " relevant patched methods."));
			foreach (DiagnosticFiles.PatchRecord item2 in list.Where((DiagnosticFiles.PatchRecord record) => record.Owners.Distinct().Count() > 1))
			{
				log.LogWarning((object)("Harmony overlap: " + item2.Target + " owners=[" + string.Join(", ", item2.Owners) + "]"));
			}
			if (writeJson)
			{
				DiagnosticFiles.WriteHarmonyInventory(list);
			}
		}

		private static string[] DescribePatches(IEnumerable<Patch> patches)
		{
			return patches.Select((Patch patch) => patch.owner + "::" + Describe(patch.PatchMethod)).ToArray();
		}

		private static string Describe(MethodBase method)
		{
			if (method == null)
			{
				return "<null>";
			}
			string text = ((method.DeclaringType == null) ? "<global>" : method.DeclaringType.FullName);
			return text + "." + method.Name + "(" + string.Join(",", (from parameter in method.GetParameters()
				select parameter.ParameterType.FullName).ToArray()) + ")";
		}
	}
	public static class OperationDiagnostics
	{
		private sealed class Metric
		{
			internal long Calls;

			internal double TotalMs;

			internal double MaxMs;
		}

		private sealed class Operation
		{
			internal int Id;

			internal string Kind;

			internal long StartedTimestamp;

			internal long RootCompletedTimestamp;

			internal double RootDurationMs;

			internal string RootError;

			internal int SlowCallLogsEmitted;

			internal long SlowCallLogsSuppressed;

			internal readonly Dictionary<string, Metric> Metrics = new Dictionary<string, Metric>();
		}

		private sealed class TargetSpec
		{
			internal readonly string TypeName;

			internal readonly string[] Methods;

			internal TargetSpec(string typeName, params string[] methods)
			{
				TypeName = typeName;
				Methods = methods;
			}
		}

		private const int MaximumIndividualSlowCallLogs = 32;

		private static readonly TargetSpec[] GeneralTargets = new TargetSpec[13]
		{
			new TargetSpec("MineRock5", "Damage", "RPC_Damage", "DamageArea", "CheckSupport", "UpdateSupport", "UpdateMesh", "SetupColliders"),
			new TargetSpec("MineRock", "Damage", "RPC_Hit"),
			new TargetSpec("TreeBase", "Damage", "RPC_Damage", "SpawnLog"),
			new TargetSpec("TreeLog", "Damage", "RPC_Damage", "Destroy"),
			new TargetSpec("Destructible", "Damage", "RPC_Damage", "Destroy", "CreateDestructionEffects"),
			new TargetSpec("TerrainComp", "DoOperation", "InternalDoOperation", "Save"),
			new TargetSpec("Heightmap", "Poke", "Regenerate", "RebuildCollisionMesh", "RebuildRenderMesh"),
			new TargetSpec("ItemDrop", "Awake", "OnCreateNew", "DropItem"),
			new TargetSpec("EffectList", "Create"),
			new TargetSpec("AudioMan", "RequestPlaySound"),
			new TargetSpec("ZSFX", "Awake", "Play"),
			new TargetSpec("ZNetView", "Awake", "InvokeRPC"),
			new TargetSpec("ZDOMan", "CreateNewZDO")
		};

		private static readonly object Gate = new object();

		private static ManualLogSource _log;

		private static Operation _current;

		private static int _nextId;

		internal static void Initialize(ManualLogSource log)
		{
			_log = log;
		}

		internal static void InstallGeneralTargets(Harmony harmony)
		{
			int num = 0;
			TargetSpec[] generalTargets = GeneralTargets;
			foreach (TargetSpec targetSpec in generalTargets)
			{
				num += RegisterTargets(harmony, targetSpec.TypeName, targetSpec.Methods);
			}
			_log.LogInfo((object)("General destruction diagnostics installed on " + num + " methods."));
		}

		public static int RegisterTargets(Harmony harmony, string typeName, params string[] methodNames)
		{
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Expected O, but got Unknown
			//IL_0111: Expected O, but got Unknown
			if (harmony == null)
			{
				throw new ArgumentNullException("harmony");
			}
			if (string.IsNullOrEmpty(typeName))
			{
				throw new ArgumentException("Type name is required.", "typeName");
			}
			Type type = AccessTools.TypeByName(typeName);
			if (type == null)
			{
				if (_log != null)
				{
					_log.LogWarning((object)("Diagnostic type not found: " + typeName));
				}
				return 0;
			}
			int num = 0;
			foreach (string methodName in methodNames.Distinct())
			{
				MethodBase[] array = (from method in type.GetMethods(BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic)
					where method.Name == methodName
					select method).Cast<MethodBase>().ToArray();
				if (array.Length == 0)
				{
					if (_log != null)
					{
						_log.LogWarning((object)("Diagnostic method not found: " + typeName + "." + methodName));
					}
					continue;
				}
				MethodBase[] array2 = array;
				foreach (MethodBase methodBase in array2)
				{
					harmony.Patch(methodBase, new HarmonyMethod(typeof(OperationDiagnostics), "ProfilePrefix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(typeof(OperationDiagnostics), "ProfileFinalizer", (Type[])null), (HarmonyMethod)null);
					num++;
				}
			}
			return num;
		}

		public static int Begin(string kind)
		{
			lock (Gate)
			{
				if (_current != null)
				{
					FinishLocked("superseded by a new operation");
				}
				_current = new Operation
				{
					Id = ++_nextId,
					Kind = (string.IsNullOrEmpty(kind) ? "unspecified" : kind),
					StartedTimestamp = Stopwatch.GetTimestamp()
				};
				if (_log != null)
				{
					_log.LogInfo((object)("Operation #" + _current.Id + " (" + _current.Kind + ") began."));
				}
				return _current.Id;
			}
		}

		public static void CompleteRoot(int operationId, double rootDurationMs, Exception error)
		{
			lock (Gate)
			{
				if (_current != null && _current.Id == operationId)
				{
					_current.RootDurationMs = rootDurationMs;
					_current.RootCompletedTimestamp = Stopwatch.GetTimestamp();
					_current.RootError = ((error == null) ? null : (error.GetType().FullName + ": " + error.Message));
				}
			}
		}

		public static void RecordCount(string name, long count)
		{
			if (string.IsNullOrEmpty(name) || count <= 0 || Volatile.Read(in _current) == null)
			{
				return;
			}
			lock (Gate)
			{
				if (_current != null)
				{
					if (!_current.Metrics.TryGetValue(name, out var value))
					{
						value = new Metric();
						_current.Metrics.Add(name, value);
					}
					value.Calls += count;
				}
			}
		}

		private static void ProfilePrefix(out long __state)
		{
			__state = ((Volatile.Read(in _current) == null) ? 0 : Stopwatch.GetTimestamp());
		}

		internal static string BenchmarkIdlePrefix(int iterations)
		{
			if (iterations < 1 || iterations > 10000000)
			{
				throw new ArgumentOutOfRangeException("iterations");
			}
			if (Volatile.Read(in _current) != null)
			{
				throw new InvalidOperationException("An operation is active.");
			}
			long __state;
			for (int i = 0; i < 10000; i++)
			{
				ProfilePrefix(out __state);
			}
			GC.Collect();
			GC.WaitForPendingFinalizers();
			GC.Collect();
			int num = GC.CollectionCount(0);
			long totalMemory = GC.GetTotalMemory(forceFullCollection: false);
			long timestamp = Stopwatch.GetTimestamp();
			for (int j = 0; j < iterations; j++)
			{
				ProfilePrefix(out __state);
			}
			long timestamp2 = Stopwatch.GetTimestamp();
			long totalMemory2 = GC.GetTotalMemory(forceFullCollection: false);
			int num2 = GC.CollectionCount(0);
			double num3 = (double)(timestamp2 - timestamp) * 1000000000.0 / (double)Stopwatch.Frequency / (double)iterations;
			return "{\"iterations\":" + iterations.ToString(CultureInfo.InvariantCulture) + ",\"nanosecondsPerCall\":" + num3.ToString("0.###", CultureInfo.InvariantCulture) + ",\"managedMemoryDeltaBytes\":" + (totalMemory2 - totalMemory).ToString(CultureInfo.InvariantCulture) + ",\"gen0Collections\":" + (num2 - num).ToString(CultureInfo.InvariantCulture) + "}";
		}

		private static Exception ProfileFinalizer(MethodBase __originalMethod, Exception __exception, long __state)
		{
			if (__state == 0L)
			{
				return __exception;
			}
			double num = ElapsedMs(__state);
			string text = __originalMethod.DeclaringType.FullName + "." + __originalMethod.Name;
			lock (Gate)
			{
				if (_current == null)
				{
					return __exception;
				}
				if (!_current.Metrics.TryGetValue(text, out var value))
				{
					value = new Metric();
					_current.Metrics.Add(text, value);
				}
				value.Calls++;
				value.TotalMs += num;
				value.MaxMs = Math.Max(value.MaxMs, num);
				if (_log != null && Plugin.Settings != null && num >= (double)Plugin.Settings.SlowCallThresholdMs.Value)
				{
					if (_current.SlowCallLogsEmitted < 32)
					{
						_current.SlowCallLogsEmitted++;
						_log.LogInfo((object)("Slow operation call #" + _current.Id + ": " + text + " took " + num.ToString("0.###", CultureInfo.InvariantCulture) + " ms."));
					}
					else
					{
						_current.SlowCallLogsSuppressed++;
					}
				}
			}
			return __exception;
		}

		internal static void FlushCompleted()
		{
			lock (Gate)
			{
				if (_current != null && _current.RootCompletedTimestamp != 0L && Plugin.Settings != null && ElapsedSeconds(_current.RootCompletedTimestamp) >= (double)Plugin.Settings.OperationTailSeconds.Value)
				{
					FinishLocked("tail window complete");
				}
			}
		}

		internal static void FlushNow(string reason)
		{
			lock (Gate)
			{
				if (_current != null)
				{
					FinishLocked(reason);
				}
			}
		}

		private static void FinishLocked(string reason)
		{
			Operation current = _current;
			_current = null;
			if (current == null)
			{
				return;
			}
			if (current.SlowCallLogsSuppressed > 0)
			{
				current.Metrics["Valayer.Diagnostics.SlowCallLogsSuppressed"] = new Metric
				{
					Calls = current.SlowCallLogsSuppressed
				};
			}
			KeyValuePair<string, Metric>[] array = current.Metrics.OrderByDescending((KeyValuePair<string, Metric> pair) => pair.Value.TotalMs).ToArray();
			if (_log != null)
			{
				_log.LogInfo((object)("Operation #" + current.Id + " (" + current.Kind + ") finished (" + reason + "). Root=" + current.RootDurationMs.ToString("0.###", CultureInfo.InvariantCulture) + " ms; groups=" + array.Length + ((current.RootError == null) ? "." : ("; error=" + current.RootError))));
				if (current.SlowCallLogsSuppressed > 0)
				{
					_log.LogInfo((object)("  Suppressed " + current.SlowCallLogsSuppressed + " additional individual slow-call log lines; aggregate metrics remain complete."));
				}
				KeyValuePair<string, Metric>[] array2 = array;
				for (int num = 0; num < array2.Length; num++)
				{
					KeyValuePair<string, Metric> keyValuePair = array2[num];
					_log.LogInfo((object)("  " + keyValuePair.Key + ": calls=" + keyValuePair.Value.Calls + ", total=" + keyValuePair.Value.TotalMs.ToString("0.###", CultureInfo.InvariantCulture) + " ms, max=" + keyValuePair.Value.MaxMs.ToString("0.###", CultureInfo.InvariantCulture) + " ms"));
				}
			}
			if (Plugin.Settings != null && Plugin.Settings.WriteJsonReports.Value)
			{
				DiagnosticFiles.WriteOperation(current.Id, current.Kind, current.RootDurationMs, current.RootError, reason, array.Select((KeyValuePair<string, Metric> pair) => new DiagnosticFiles.MetricRecord(pair.Key, pair.Value.Calls, pair.Value.TotalMs, pair.Value.MaxMs)));
			}
		}

		private static double ElapsedMs(long timestamp)
		{
			return (double)(Stopwatch.GetTimestamp() - timestamp) * 1000.0 / (double)Stopwatch.Frequency;
		}

		private static double ElapsedSeconds(long timestamp)
		{
			return (double)(Stopwatch.GetTimestamp() - timestamp) / (double)Stopwatch.Frequency;
		}
	}
	[BepInPlugin("foundation.valayer.heimordination", "Valayer of Heimordination", "1.1.8")]
	[BepInProcess("valheim.exe")]
	[BepInProcess("valheim_server.exe")]
	public sealed class Plugin : BaseUnityPlugin
	{
		public const string PluginGuid = "foundation.valayer.heimordination";

		public const string PluginName = "Valayer of Heimordination";

		public const string PluginVersion = "1.1.8";

		private Harmony _harmony;

		private bool _startupReportWritten;

		internal static ManualLogSource Log { get; private set; }

		internal static CoreConfig Settings { get; private set; }

		private void Awake()
		{
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Expected O, but got Unknown
			Log = ((BaseUnityPlugin)this).Logger;
			Settings = CoreConfig.Bind(((BaseUnityPlugin)this).Config);
			Settings.LogEffective(Log);
			DiagnosticStorage.Initialize(Log, Settings.DiagnosticMaximumSessions.Value, Settings.DiagnosticMaximumOperationReports.Value);
			DestructionRealizationCoordinator.Initialize(Settings.ExperimentalDestructionCoordination.Value, Settings.DestructionMaximumSpatialGroups.Value, Settings.DestructionMaximumTrackedEvents.Value);
			if (!Settings.Enabled.Value)
			{
				Log.LogInfo((object)"Valayer Core disabled by [General] Enabled.");
				return;
			}
			_harmony = new Harmony("foundation.valayer.heimordination");
			if (Settings.DiagnosticsEnabled.Value)
			{
				OperationDiagnostics.Initialize(Log);
				OperationDiagnostics.InstallGeneralTargets(_harmony);
			}
			Log.LogInfo((object)"Valayer of Heimordination 1.1.8 loaded. Core has no SuperViking or Jotunn runtime dependency.");
		}

		private void Start()
		{
			WriteStartupReport();
		}

		private void Update()
		{
			if (_harmony != null && Settings.DiagnosticsEnabled.Value)
			{
				OperationDiagnostics.FlushCompleted();
				if (!_startupReportWritten)
				{
					WriteStartupReport();
				}
			}
		}

		private void WriteStartupReport()
		{
			if (!_startupReportWritten && _harmony != null && Settings.DiagnosticsEnabled.Value)
			{
				_startupReportWritten = true;
				HarmonyInventory.Write(Log, Settings.WriteJsonReports.Value);
			}
		}

		private void OnDestroy()
		{
			OperationDiagnostics.FlushNow("core shutdown");
			DestructionRealizationCoordinator.Shutdown();
			DiagnosticStorage.Shutdown();
			if (_harmony != null)
			{
				_harmony.UnpatchSelf();
				_harmony = null;
			}
		}
	}
}
namespace Valayer.Core.Temporal
{
	public enum TemporalAuthorityRequestResult
	{
		Accepted,
		RejectedInvalid,
		RejectedStale,
		RejectedRate,
		RejectedCapacity
	}
	public sealed class TemporalAuthorityRequestGate
	{
		private struct RequestKey : IEquatable<RequestKey>
		{
			internal long OwnerId;

			internal int FieldId;

			public bool Equals(RequestKey other)
			{
				if (OwnerId == other.OwnerId)
				{
					return FieldId == other.FieldId;
				}
				return false;
			}

			public override bool Equals(object value)
			{
				if (value is RequestKey)
				{
					return Equals((RequestKey)value);
				}
				return false;
			}

			public override int GetHashCode()
			{
				return (OwnerId.GetHashCode() * 397) ^ FieldId;
			}
		}

		private sealed class RequestState
		{
			internal int Sequence;

			internal bool Active;

			internal float LastAcceptedAt;

			internal float ExpiresAt;
		}

		private readonly Dictionary<RequestKey, RequestState> _states = new Dictionary<RequestKey, RequestState>();

		private readonly List<RequestKey> _removeBuffer = new List<RequestKey>();

		public int TrackedCount => _states.Count;

		public int ActiveCount
		{
			get
			{
				int num = 0;
				foreach (RequestState value in _states.Values)
				{
					if (value.Active)
					{
						num++;
					}
				}
				return num;
			}
		}

		public TemporalAuthorityRequestResult Receive(long authenticatedOwnerId, int fieldId, int sequence, bool active, float now, float activeLifetimeSeconds)
		{
			Expire(now);
			if (authenticatedOwnerId == 0L || fieldId == 0 || !IsFinite(now) || !IsFinite(activeLifetimeSeconds) || activeLifetimeSeconds <= 0f || activeLifetimeSeconds > 10f)
			{
				return TemporalAuthorityRequestResult.RejectedInvalid;
			}
			RequestKey key = new RequestKey
			{
				OwnerId = authenticatedOwnerId,
				FieldId = fieldId
			};
			RequestState value;
			bool flag = _states.TryGetValue(key, out value);
			if (flag && !TemporalFieldRules.ShouldAccept(hasState: true, value.Sequence, sequence))
			{
				return TemporalAuthorityRequestResult.RejectedStale;
			}
			float num = 0.1f;
			if (active && flag && now - value.LastAcceptedAt + 1E-06f < num)
			{
				return TemporalAuthorityRequestResult.RejectedRate;
			}
			if (!flag)
			{
				if (active && ActiveCount >= 32)
				{
					return TemporalAuthorityRequestResult.RejectedCapacity;
				}
				if (_states.Count >= 64 && !EvictOldestInactive())
				{
					return TemporalAuthorityRequestResult.RejectedCapacity;
				}
				value = new RequestState();
				_states.Add(key, value);
			}
			else if (!value.Active && active && ActiveCount >= 32)
			{
				return TemporalAuthorityRequestResult.RejectedCapacity;
			}
			value.Sequence = sequence;
			value.Active = active;
			value.LastAcceptedAt = now;
			value.ExpiresAt = now + (active ? activeLifetimeSeconds : 5f);
			return TemporalAuthorityRequestResult.Accepted;
		}

		public void RemoveOwner(long ownerId)
		{
			_removeBuffer.Clear();
			foreach (RequestKey key in _states.Keys)
			{
				if (key.OwnerId == ownerId)
				{
					_removeBuffer.Add(key);
				}
			}
			for (int i = 0; i < _removeBuffer.Count; i++)
			{
				_states.Remove(_removeBuffer[i]);
			}
		}

		public void RemoveDisconnected(Predicate<long> isConnected)
		{
			if (isConnected == null)
			{
				return;
			}
			_removeBuffer.Clear();
			foreach (RequestKey key in _states.Keys)
			{
				if (!isConnected(key.OwnerId))
				{
					_removeBuffer.Add(key);
				}
			}
			for (int i = 0; i < _removeBuffer.Count; i++)
			{
				_states.Remove(_removeBuffer[i]);
			}
		}

		public void Expire(float now)
		{
			if (!IsFinite(now))
			{
				return;
			}
			_removeBuffer.Clear();
			foreach (KeyValuePair<RequestKey, RequestState> state in _states)
			{
				RequestState value = state.Value;
				if (!(now < value.ExpiresAt))
				{
					if (value.Active)
					{
						value.Active = false;
						value.ExpiresAt = now + 5f;
					}
					else
					{
						_removeBuffer.Add(state.Key);
					}
				}
			}
			for (int i = 0; i < _removeBuffer.Count; i++)
			{
				_states.Remove(_removeBuffer[i]);
			}
		}

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

		private bool EvictOldestInactive()
		{
			bool flag = false;
			RequestKey key = default(RequestKey);
			float num = float.MaxValue;
			foreach (KeyValuePair<RequestKey, RequestState> state in _states)
			{
				if (!state.Value.Active && state.Value.LastAcceptedAt < num)
				{
					flag = true;
					num = state.Value.LastAcceptedAt;
					key = state.Key;
				}
			}
			if (flag)
			{
				return _states.Remove(key);
			}
			return false;
		}

		private static bool IsFinite(float value)
		{
			if (!float.IsNaN(value))
			{
				return !float.IsInfinity(value);
			}
			return false;
		}
	}
	public enum TemporalAudience
	{
		Everybody,
		OwnerOnly,
		OthersOnly
	}
	public enum TemporalEntityKind
	{
		Creature,
		Projectile
	}
	public enum TemporalDomainShape
	{
		Box,
		Sphere
	}
	public enum TemporalRelation
	{
		Unknown,
		Self,
		Ally,
		Neutral,
		Hostile
	}
	[Flags]
	public enum TemporalInteractionPermissions
	{
		None = 0,
		HostileCreatures = 1,
		NeutralCreatures = 2,
		AlliedCreatures = 4,
		HostileProjectiles = 8,
		NeutralProjectiles = 0x10,
		AlliedProjectiles = 0x20,
		OwnProjectiles = 0x40
	}
	public enum TemporalReceiveResult
	{
		Accepted,
		RejectedProtocol,
		RejectedInvalid,
		RejectedStale,
		RejectedCapacity
	}
	public struct TemporalPoint
	{
		public float X;

		public float Y;

		public float Z;

		public TemporalPoint(float x, float y, float z)
		{
			X = x;
			Y = y;
			Z = z;
		}
	}
	public struct TemporalFieldPacket
	{
		public int ProtocolVersion;

		public int FieldId;

		public int Sequence;

		public long OwnerId;

		public long AuthorityId;

		public int PolicyRevision;

		public int PrecedenceRank;

		public bool Active;

		public TemporalPoint Center;

		public TemporalDomainShape Shape;

		public TemporalPoint Dimensions;

		public float TimeScale;

		public float SimulationResolutionHz;

		public float LifetimeSeconds;

		public TemporalAudience Audience;

		public TemporalInteractionPermissions Permissions;
	}
	public struct TemporalEvaluation
	{
		public float TimeScale;

		public int ContributingFields;

		public float SimulationResolutionHz;

		internal TemporalEvaluation(float timeScale, int contributingFields, float simulationResolutionHz = 50f)
		{
			TimeScale = timeScale;
			ContributingFields = contributingFields;
			SimulationResolutionHz = simulationResolutionHz;
		}
	}
	public static class TemporalFieldRules
	{
		public const int ProtocolVersion = 4;

		public const int MaximumActiveFields = 32;

		public const int MaximumTrackedStates = 64;

		public const float MinimumDimension = 1f;

		public const float MaximumDimension = 400f;

		public const float MinimumTimeScale = 0.05f;

		public const float MaximumLifetimeSeconds = 10f;

		public const float MinimumSimulationResolutionHz = 10f;

		public const float MaximumSimulationResolutionHz = 50f;

		public const float StopTombstoneSeconds = 5f;

		public const float MaximumUpdatesPerSecondPerField = 10f;

		public const TemporalInteractionPermissions AllPermissions = TemporalInteractionPermissions.HostileCreatures | TemporalInteractionPermissions.NeutralCreatures | TemporalInteractionPermissions.AlliedCreatures | TemporalInteractionPermissions.HostileProjectiles | TemporalInteractionPermissions.NeutralProjectiles | TemporalInteractionPermissions.AlliedProjectiles | TemporalInteractionPermissions.OwnProjectiles;

		public static bool IsValid(TemporalFieldPacket packet)
		{
			if (packet.ProtocolVersion != 4 || packet.FieldId == 0 || packet.AuthorityId == 0L || packet.OwnerId == 0L || packet.PolicyRevision <= 0 || packet.PrecedenceRank < 0)
			{
				return false;
			}
			if (!packet.Active)
			{
				return true;
			}
			if (IsFinite(packet.Center.X) && IsFinite(packet.Center.Y) && IsFinite(packet.Center.Z) && Enum.IsDefined(typeof(TemporalDomainShape), packet.Shape) && IsValidDimension(packet.Dimensions.X) && IsValidDimension(packet.Dimensions.Y) && IsValidDimension(packet.Dimensions.Z) && (packet.Shape != TemporalDomainShape.Sphere || (packet.Dimensions.X == packet.Dimensions.Y && packet.Dimensions.X == packet.Dimensions.Z)) && IsFinite(packet.TimeScale) && packet.TimeScale >= 0.05f && packet.TimeScale <= 1f && IsFinite(packet.SimulationResolutionHz) && packet.SimulationResolutionHz >= 10f && packet.SimulationResolutionHz <= 50f && IsFinite(packet.LifetimeSeconds) && packet.LifetimeSeconds > 0f && packet.LifetimeSeconds <= 10f && Enum.IsDefined(typeof(TemporalAudience), packet.Audience))
			{
				return (packet.Permissions & ~(TemporalInteractionPermissions.HostileCreatures | TemporalInteractionPermissions.NeutralCreatures | TemporalInteractionPermissions.AlliedCreatures | TemporalInteractionPermissions.HostileProjectiles | TemporalInteractionPermissions.NeutralProjectiles | TemporalInteractionPermissions.AlliedProjectiles | TemporalInteractionPermissions.OwnProjectiles)) == 0;
			}
			return false;
		}

		public static bool ShouldAccept(bool hasState, int currentSequence, int incomingSequence)
		{
			if (hasState)
			{
				return incomingSequence - currentSequence > 0;
			}
			return true;
		}

		public static bool Contains(TemporalFieldPacket packet, TemporalPoint subject)
		{
			float num = subject.X - packet.Center.X;
			float num2 = subject.Y - packet.Center.Y;
			float num3 = subject.Z - packet.Center.Z;
			if (packet.Shape == TemporalDomainShape.Sphere)
			{
				float num4 = packet.Dimensions.X * 0.5f;
				return num * num + num2 * num2 + num3 * num3 <= num4 * num4;
			}
			if (Math.Abs(num) <= packet.Dimensions.X * 0.5f && Math.Abs(num2) <= packet.Dimensions.Y * 0.5f)
			{
				return Math.Abs(num3) <= packet.Dimensions.Z * 0.5f;
			}
			return false;
		}

		public static bool Affects(TemporalAudience audience, long ownerId, long subjectId)
		{
			return audience switch
			{
				TemporalAudience.OwnerOnly => ownerId == subjectId, 
				TemporalAudience.OthersOnly => ownerId != subjectId, 
				_ => true, 
			};
		}

		public static bool AffectsEntity(TemporalInteractionPermissions permissions, TemporalEntityKind kind, TemporalRelation relation)
		{
			TemporalInteractionPermissions temporalInteractionPermissions;
			switch (kind)
			{
			case TemporalEntityKind.Projectile:
				switch (relation)
				{
				case TemporalRelation.Self:
					temporalInteractionPermissions = TemporalInteractionPermissions.OwnProjectiles;
					break;
				case TemporalRelation.Ally:
					temporalInteractionPermissions = TemporalInteractionPermissions.AlliedProjectiles;
					break;
				case TemporalRelation.Neutral:
					temporalInteractionPermissions = TemporalInteractionPermissions.NeutralProjectiles;
					break;
				case TemporalRelation.Hostile:
					temporalInteractionPermissions = TemporalInteractionPermissions.HostileProjectiles;
					break;
				default:
					return false;
				}
				break;
			case TemporalEntityKind.Creature:
				switch (relation)
				{
				case TemporalRelation.Self:
				case TemporalRelation.Ally:
					temporalInteractionPermissions = TemporalInteractionPermissions.AlliedCreatures;
					break;
				case TemporalRelation.Neutral:
					temporalInteractionPermissions = TemporalInteractionPermissions.NeutralCreatures;
					break;
				case TemporalRelation.Hostile:
					temporalInteractionPermissions = TemporalInteractionPermissions.HostileCreatures;
					break;
				default:
					return false;
				}
				break;
			default:
				return false;
			}
			return (permissions & temporalInteractionPermissions) != 0;
		}

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

		private static bool IsValidDimension(float value)
		{
			if (IsFinite(value) && value >= 1f)
			{
				return value <= 400f;
			}
			return false;
		}
	}
	public static class TemporalCompatibilityRules
	{
		public const int CapabilityProtocolVersion = 1;

		public const float MaximumCapabilityAgeSeconds = 7f;

		public static bool IsCompatible(int temporalProtocol, bool enabled, float ageSeconds)
		{
			if (temporalProtocol == 4 && enabled && !float.IsNaN(ageSeconds) && !float.IsInfinity(ageSeconds) && ageSeconds >= 0f)
			{
				return ageSeconds <= 7f;
			}
			return false;
		}
	}
	public enum TemporalCirclePlane
	{
		XY,
		XZ,
		YZ
	}
	public static class TemporalDomainGeometry
	{
		public const int BoxCornerCount = 8;

		public const int BoxEdgeCount = 12;

		private static readonly int[] EdgeCorners = new int[24]
		{
			0, 1, 1, 2, 2, 3, 3, 0, 4, 5,
			5, 6, 6, 7, 7, 4, 0, 4, 1, 5,
			2, 6, 3, 7
		};

		public static TemporalPoint BoxCorner(TemporalPoint dimensions, int index)
		{
			if (index < 0 || index >= 8)
			{
				throw new ArgumentOutOfRangeException("index");
			}
			float num = dimensions.X * 0.5f;
			float num2 = dimensions.Y * 0.5f;
			float num3 = dimensions.Z * 0.5f;
			return index switch
			{
				0 => new TemporalPoint(0f - num, 0f - num2, 0f - num3), 
				1 => new TemporalPoint(num, 0f - num2, 0f - num3), 
				2 => new TemporalPoint(num, 0f - num2, num3), 
				3 => new TemporalPoint(0f - num, 0f - num2, num3), 
				4 => new TemporalPoint(0f - num, num2, 0f - num3), 
				5 => new TemporalPoint(num, num2, 0f - num3), 
				6 => new TemporalPoint(num, num2, num3), 
				_ => new TemporalPoint(0f - num, num2, num3), 
			};
		}

		public static int BoxEdgeCorner(int edge, bool end)
		{
			if (edge < 0 || edge >= 12)
			{
				throw new ArgumentOutOfRangeException("edge");
			}
			return EdgeCorners[edge * 2 + (end ? 1 : 0)];
		}

		public static TemporalPoint SpherePoint(float diameter, TemporalCirclePlane plane, float radians)
		{
			float num = diameter * 0.5f;
			float num2 = (float)Math.Cos(radians) * num;
			float num3 = (float)Math.Sin(radians) * num;
			return plane switch
			{
				TemporalCirclePlane.XY => new TemporalPoint(num2, num3, 0f), 
				TemporalCirclePlane.XZ => new TemporalPoint(num2, 0f, num3), 
				_ => new TemporalPoint(0f, num2, num3), 
			};
		}
	}
	public delegate TemporalRelation TemporalRelationResolver(long fieldOwnerId);
	public sealed class TemporalFieldRegistry
	{
		private struct FieldKey : IEquatable<FieldKey>
		{
			internal long OwnerId;

			internal int FieldId;

			public bool Equals(FieldKey other)
			{
				if (OwnerId == other.OwnerId)
				{
					return FieldId == other.FieldId;
				}
				return false;
			}

			public override bool Equals(object value)
			{
				if (value is FieldKey)
				{
					return Equals((FieldKey)value);
				}
				return false;
			}

			public override int GetHashCode()
			{
				return (OwnerId.GetHashCode() * 397) ^ FieldId;
			}
		}

		private sealed class FieldState
		{
			internal int Sequence;

			internal bool Active;

			internal TemporalFieldPacket Packet;

			internal float ExpiresAt;

			internal float LastChangedAt;
		}

		private readonly Dictionary<FieldKey, FieldState> _states = new Dictionary<FieldKey, FieldState>();

		private readonly List<FieldKey> _removeBuffer = new List<FieldKey>();

		private float _nextExpiryAt = float.PositiveInfinity;

		private long _authorityId;

		private int _policyRevision;

		public int ActiveCount
		{
			get
			{
				int num = 0;
				foreach (FieldState value in _states.Values)
				{
					if (value.Active)
					{
						num++;
					}
				}
				return num;
			}
		}

		public int TrackedCount => _states.Count;

		public long AuthorityId => _authorityId;

		public int PolicyRevision => _policyRevision;

		public TemporalReceiveResult Receive(long authenticatedAuthorityId, TemporalFieldPacket packet, float now)
		{
			Expire(now);
			if (packet.ProtocolVersion != 4)
			{
				return TemporalReceiveResult.RejectedProtocol;
			}
			if (!TemporalFieldRules.IsValid(packet) || packet.AuthorityId != authenticatedAuthorityId || !IsFinite(now) || (_authorityId != 0L && _authorityId != authenticatedAuthorityId))
			{
				return TemporalReceiveResult.RejectedInvalid;
			}
			if (packet.PolicyRevision < _policyRevision)
			{
				return TemporalReceiveResult.RejectedStale;
			}
			if (_authorityId == 0L)
			{
				_authorityId = authenticatedAuthorityId;
			}
			if (packet.PolicyRevision > _policyRevision)
			{
				_states.Clear();
				_nextExpiryAt = float.PositiveInfinity;
				_policyRevision = packet.PolicyRevision;
			}
			FieldKey key = new FieldKey
			{
				OwnerId = packet.OwnerId,
				FieldId = packet.FieldId
			};
			FieldState value;
			bool flag = _states.TryGetValue(key, out value);
			if (!TemporalFieldRules.ShouldAccept(flag, flag ? value.Sequence : 0, packet.Sequence))
			{
				return TemporalReceiveResult.RejectedStale;
			}
			if (!flag)
			{
				if (packet.Active && ActiveCount >= 32)
				{
					return TemporalReceiveResult.RejectedCapacity;
				}
				if (_states.Count >= 64 && !EvictOldestTombstone())
				{
					return TemporalReceiveResult.RejectedCapacity;
				}
				value = new FieldState();
				_states.Add(key, value);
			}
			else if (!value.Active && packet.Active && ActiveCount >= 32)
			{
				return TemporalReceiveResult.RejectedCapacity;
			}
			value.Sequence = packet.Sequence;
			value.Active = packet.Active;
			value.Packet = packet;
			value.LastChangedAt = now;
			value.ExpiresAt = now + (packet.Active ? packet.LifetimeSeconds : 5f);
			if (value.ExpiresAt < _nextExpiryAt)
			{
				_nextExpiryAt = value.ExpiresAt;
			}
			return TemporalReceiveResult.Accepted;
		}

		public TemporalEvaluation Evaluate(TemporalPoint subject, long subjectId, bool independentlyEligible, float now)
		{
			Expire(now);
			return new TemporalEvaluation(1f, 0);
		}

		public TemporalEvaluation EvaluateEntity(TemporalPoint subject, TemporalEntityKind kind, bool independentlyEligible, TemporalRelationResolver resolveRelation, float now)
		{
			Expire(now);
			if (!independentlyEligible || resolveRelation == null || !IsFinite(subject.X) || !IsFinite(subject.Y) || !IsFinite(subject.Z))
			{
				return new TemporalEvaluation(1f, 0);
			}
			float timeScale = 1f;
			int num = 0;
			int num2 = int.MaxValue;
			long num3 = long.MaxValue;
			int num4 = int.MaxValue;
			float simulationResolutionHz = 50f;
			foreach (FieldState value in _states.Values)
			{
				TemporalFieldPacket packet = value.Packet;
				if (value.Active && TemporalFieldRules.Contains(packet, subject) && TemporalFieldRules.AffectsEntity(packet.Permissions, kind, resolveRelation(packet.OwnerId)))
				{
					num++;
					if (packet.PrecedenceRank < num2 || (packet.PrecedenceRank == num2 && packet.OwnerId < num3) || (packet.PrecedenceRank == num2 && packet.OwnerId == num3 && packet.FieldId < num4))
					{
						num2 = packet.PrecedenceRank;
						num3 = packet.OwnerId;
						num4 = packet.FieldId;
						timeScale = packet.TimeScale;
						simulationResolutionHz = packet.SimulationResolutionHz;
					}
				}
			}
			return new TemporalEvaluation(timeScale, num, simulationResolutionHz);
		}

		public void RemoveSender(long ownerId)
		{
			List<FieldKey> list = new List<FieldKey>();
			foreach (FieldKey key in _states.Keys)
			{
				if (key.OwnerId == ownerId)
				{
					list.Add(key);
				}
			}
			for (int i = 0; i < list.Count; i++)
			{
				_states.Remove(list[i]);
			}
			RecalculateNextExpiry();
		}

		public void Clear()
		{
			_states.Clear();
			_nextExpiryAt = float.PositiveInfinity;
			_authorityId = 0L;
			_policyRevision = 0;
		}

		public void Expire(float now)
		{
			if (!IsFinite(now) || now < _nextExpiryAt)
			{
				return;
			}
			_removeBuffer.Clear();
			_nextExpiryAt = float.PositiveInfinity;
			foreach (KeyValuePair<FieldKey, FieldState> state in _states)
			{
				FieldState value = state.Value;
				if (now >= value.ExpiresAt)
				{
					if (!value.Active)
					{
						_removeBuffer.Add(state.Key);
						continue;
					}
					value.Active = false;
					value.Packet.Active = false;
					value.LastChangedAt = now;
					value.ExpiresAt = now + 5f;
				}
				if (value.ExpiresAt < _nextExpiryAt)
				{
					_nextExpiryAt = value.ExpiresAt;
				}
			}
			for (int i = 0; i < _removeBuffer.Count; i++)
			{
				_states.Remove(_removeBuffer[i]);
			}
		}

		private bool EvictOldestTombstone()
		{
			bool flag = false;
			FieldKey key = default(FieldKey);
			float num = float.MaxValue;
			foreach (KeyValuePair<FieldKey, FieldState> state in _states)
			{
				if (!state.Value.Active && state.Value.LastChangedAt < num)
				{
					flag = true;
					num = state.Value.LastChangedAt;
					key = state.Key;
				}
			}
			if (flag)
			{
				return _states.Remove(key);
			}
			return false;
		}

		private void RecalculateNextExpiry()
		{
			_nextExpiryAt = float.PositiveInfinity;
			foreach (FieldState value in _states.Values)
			{
				if (value.ExpiresAt < _nextExpiryAt)
				{
					_nextExpiryAt = value.ExpiresAt;
				}
			}
		}

		private static bool IsFinite(float value)
		{
			if (!float.IsNaN(value))
			{
				return !float.IsInfinity(value);
			}
			return false;
		}
	}
	public static class TemporalStepAdmission
	{
		public static bool ShouldAdvance(float timeScale, ref float accumulator)
		{
			if (float.IsNaN(timeScale) || float.IsInfinity(timeScale) || timeScale >= 1f)
			{
				accumulator = 0f;
				return true;
			}
			if (timeScale < 0.05f)
			{
				timeScale = 0.05f;
			}
			accumulator += timeScale;
			if (accumulator + 1E-06f < 1f)
			{
				return false;
			}
			accumulator -= 1f;
			return true;
		}
	}
}
namespace Valayer.Core.Representation
{
	public enum SharedActionPhase
	{
		Idle,
		Preparing,
		Holding,
		Executing,
		Recovery,
		Interrupted
	}
	public enum SharedActionReceiveResult
	{
		Accepted,
		RejectedProtocol,
		RejectedInvalid,
		RejectedUnauthenticated,
		RejectedStale,
		RejectedTransition,
		RejectedCapacity
	}
	public struct SharedActionPacket
	{
		public int ProtocolVersion;

		public long ActorId;

		public uint ActorObjectId;

		public int ActionKind;

		public int ActionId;

		public int Sequence;

		public SharedActionPhase Phase;

		public long TargetOwnerId;

		public uint TargetObjectId;

		public float LifetimeSeconds;
	}
	public struct SharedActionSnapshot
	{
		public SharedActionPacket Packet;

		public float ReceivedAt;
	}
	public static class SharedActionProtocol
	{
		public const int ProtocolVersion = 1;

		public const int MaximumTrackedActions = 32;

		public const float MinimumLifetimeSeconds = 0.5f;

		public const float MaximumLifetimeSeconds = 5f;

		public static bool IsValid(SharedActionPacket packet)
		{
			if (packet.ProtocolVersion == 1 && packet.ActorId != 0L && packet.ActorObjectId != 0 && packet.ActionKind > 0 && packet.ActionId != 0 && packet.Sequence > 0 && Enum.IsDefined(typeof(SharedActionPhase), packet.Phase) && packet.LifetimeSeconds >= 0.5f && packet.LifetimeSeconds <= 5f)
			{
				if (packet.Phase != SharedActionPhase.Preparing && (packet.TargetOwnerId == 0L || packet.TargetObjectId == 0) && packet.Phase != SharedActionPhase.Interrupted && packet.Phase != SharedActionPhase.Recovery)
				{
					return packet.Phase == SharedActionPhase.Idle;
				}
				return true;
			}
			return false;
		}

		public static bool IsNewer(int current, int incoming)
		{
			return incoming - current > 0;
		}

		public static bool CanTransition(SharedActionPhase current, SharedActionPhase next)
		{
			if (current == next)
			{
				return true;
			}
			switch (current)
			{
			case SharedActionPhase.Preparing:
				if (next != SharedActionPhase.Holding)
				{
					return next == SharedActionPhase.Interrupted;
				}
				return true;
			case SharedActionPhase.Holding:
				if (next != SharedActionPhase.Executing)
				{
					return next == SharedActionPhase.Interrupted;
				}
				return true;
			case SharedActionPhase.Executing:
				if (next != SharedActionPhase.Recovery)
				{
					return next == SharedActionPhase.Interrupted;
				}
				return true;
			case SharedActionPhase.Idle:
			case SharedActionPhase.Recovery:
			case SharedActionPhase.Interrupted:
				if (next != SharedActionPhase.Preparing)
				{
					return next == SharedActionPhase.Idle;
				}
				return true;
			default:
				return false;
			}
		}
	}
	public sealed class SharedActionRegistry
	{
		private struct Key : IEquatable<Key>
		{
			internal long Actor;

			internal int Kind;

			public bool Equals(Key other)
			{
				if (Actor == other.Actor)
				{
					return Kind == other.Kind;
				}
				return false;
			}

			public override bool Equals(object value)
			{
				if (value is Key)
				{
					return Equals((Key)value);
				}
				return false;
			}

			public override int GetHashCode()
			{
				return ((int)Actor * 397) ^ Kind;
			}
		}

		private readonly Dictionary<Key, SharedActionSnapshot> _states = new Dictionary<Key, SharedActionSnapshot>();

		public int Count => _states.Count;

		public SharedActionReceiveResult Receive(long authenticatedSender, SharedActionPacket packet, float now)
		{
			if (packet.ProtocolVersion != 1)
			{
				return SharedActionReceiveResult.RejectedProtocol;
			}
			if (!SharedActionProtocol.IsValid(packet))
			{
				return SharedActionReceiveResult.RejectedInvalid;
			}
			if (authenticatedSender == 0L || packet.ActorId != authenticatedSender)
			{
				return SharedActionReceiveResult.RejectedUnauthenticated;
			}
			Key key = new Key
			{
				Actor = packet.ActorId,
				Kind = packet.ActionKind
			};
			if (_states.TryGetValue(key, out var value))
			{
				if (packet.ActionId == value.Packet.ActionId)
				{
					if (!SharedActionProtocol.IsNewer(value.Packet.Sequence, packet.Sequence))
					{
						return SharedActionReceiveResult.RejectedStale;
					}
					if (!SharedActionProtocol.CanTransition(value.Packet.Phase, packet.Phase))
					{
						return SharedActionReceiveResult.RejectedTransition;
					}
				}
				else if (!SharedActionProtocol.IsNewer(value.Packet.ActionId, packet.ActionId))
				{
					return SharedActionReceiveResult.RejectedStale;
				}
			}
			else if (_states.Count >= 32)
			{
				return SharedActionReceiveResult.RejectedCapacity;
			}
			_states[key] = new SharedActionSnapshot
			{
				Packet = packet,
				ReceivedAt = now
			};
			return SharedActionReceiveResult.Accepted;
		}

		public bool TryGet(long actorId, int actionKind, out SharedActionSnapshot snapshot)
		{
			return _states.TryGetValue(new Key
			{
				Actor = actorId,
				Kind = actionKind
			}, out snapshot);
		}

		public int Expire(float now)
		{
			List<Key> list = new List<Key>();
			foreach (KeyValuePair<Key, SharedActionSnapshot> state in _states)
			{
				if (now - state.Value.ReceivedAt > state.Value.Packet.LifetimeSeconds)
				{
					list.Add(state.Key);
				}
			}
			foreach (Key item in list)
			{
				_states.Remove(item);
			}
			return list.Count;
		}

		public int RemoveActor(long actorId)
		{
			List<Key> list = new List<Key>();
			foreach (KeyValuePair<Key, SharedActionSnapshot> state in _states)
			{
				if (state.Key.Actor == actorId)
				{
					list.Add(state.Key);
				}
			}
			foreach (Key item in list)
			{
				_states.Remove(item);
			}
			return list.Count;
		}

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