using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Json;
using System.Runtime.Versioning;
using System.Text;
using ArenaGuard.Arenas;
using ArenaGuard.Challenges;
using ArenaGuard.Config;
using ArenaGuard.Domain;
using ArenaGuard.Networking;
using ArenaGuard.Persistence;
using ArenaGuard.Rules;
using ArenaGuard.Runtime;
using ArenaGuard.Sessions;
using ArenaGuard.UI;
using ArenaGuard.World;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using Jotunn.Configs;
using Jotunn.Entities;
using Jotunn.Managers;
using Jotunn.Utils;
using Microsoft.CodeAnalysis;
using UnityEngine;
using UnityEngine.Events;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyCompany("jg224")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyDescription("Server-authoritative NPC activities and challenge arenas for Valheim.")]
[assembly: AssemblyFileVersion("0.0.3.0")]
[assembly: AssemblyInformationalVersion("0.0.3+4b928f71d565c5898a4e848cd991c0793cffd286")]
[assembly: AssemblyProduct("SkaldHall")]
[assembly: AssemblyTitle("SkaldHall")]
[assembly: AssemblyVersion("0.0.3.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 ArenaGuard
{
	[BepInPlugin("jg224.arenaguard", "SkaldHall", "0.0.3")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[NetworkCompatibility(/*Could not decode attribute arguments.*/)]
	public sealed class Plugin : BaseUnityPlugin
	{
		public const string PluginGuid = "jg224.arenaguard";

		public const string PluginName = "SkaldHall";

		public const string PluginVersion = "0.0.3";

		public const string JotunnGuid = "com.jotunn.jotunn";

		private Harmony _harmony;

		internal static ManualLogSource Log { get; private set; }

		private void Awake()
		{
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Expected O, but got Unknown
			Log = ((BaseUnityPlugin)this).Logger;
			ArenaConfig.Bind(((BaseUnityPlugin)this).Config);
			CommandManager.Instance.AddConsoleCommand((ConsoleCommand)(object)new ArenaAdminCommand());
			PrefabManager.OnVanillaPrefabsAvailable += RegisterWorldPrefabs;
			ArenaServerRuntime.Initialize();
			_harmony = new Harmony("jg224.arenaguard");
			_harmony.PatchAll(typeof(Plugin).Assembly);
			SpeedyPathsCompatibility.TryInstall(_harmony);
			Log.LogInfo((object)"SkaldHall v0.0.3 loaded. The same version is required on the server and every client.");
		}

		private void Update()
		{
			ArenaWorldObjects.HandleAdminVisualToggle();
			ArenaWorldObjects.GrantOrRemoveAdminHammer();
			ArenaServerRuntime.TickOnMainThread();
		}

		private void OnDestroy()
		{
			PrefabManager.OnVanillaPrefabsAvailable -= RegisterWorldPrefabs;
			ArenaServerRuntime.Shutdown();
			ArenaWorldObjects.Shutdown();
			Harmony harmony = _harmony;
			if (harmony != null)
			{
				harmony.UnpatchSelf();
			}
		}

		private static void RegisterWorldPrefabs()
		{
			PrefabManager.OnVanillaPrefabsAvailable -= RegisterWorldPrefabs;
			ArenaWorldObjects.RegisterPrefabs();
		}

		internal static void Debug(string message)
		{
			ConfigEntry<bool> verboseLogging = ArenaConfig.VerboseLogging;
			if (verboseLogging != null && verboseLogging.Value)
			{
				ManualLogSource log = Log;
				if (log != null)
				{
					log.LogInfo((object)("[debug] " + message));
				}
			}
		}
	}
}
namespace ArenaGuard.World
{
	public sealed class ArenaGateDestination
	{
		public string GateId;

		public string ArenaId;

		public Vector3 Position;

		public Quaternion Rotation;

		public float ExitDistance;
	}
	public static class ArenaTeleporters
	{
		internal const string ZdoIsHub = "arenaguard.is_hub_gate";

		internal const string ZdoIsFallback = "arenaguard.is_fallback_gate";

		public static Func<Player, string, bool, bool> GateTravelRequested;

		public static Action<string, string, string, bool> GateConfigurationRequested;

		public static Func<string, ArenaGateDestination> EntranceDestinationResolver;

		public static Func<long, ArenaGateDestination> ReturnDestinationResolver;

		public static Func<PlayerArenaRoute, bool> RouteRecorder;

		public static Action<long> RouteRollback;

		public static Action<long> SuccessfulReturn;

		public static ArenaGateDestination DestinationFromGate(ArenaGateDefinition gate, float exitDistance = 2f)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			if (gate == null)
			{
				return null;
			}
			return new ArenaGateDestination
			{
				GateId = gate.GateId,
				ArenaId = gate.ArenaId,
				Position = ArenaWorldObjects.ToVector3(gate.Position),
				Rotation = Quaternion.Euler(0f, gate.RotationY, 0f),
				ExitDistance = exitDistance
			};
		}

		public static bool ApplyAuthorizedGateTravel(PositionData destination, float rotationY)
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			Player localPlayer = Player.m_localPlayer;
			if (!CanUseVanillaPortal(localPlayer) || float.IsNaN(rotationY) || float.IsInfinity(rotationY))
			{
				return false;
			}
			return Teleport(localPlayer, new ArenaGateDestination
			{
				Position = ArenaWorldObjects.ToVector3(destination),
				Rotation = Quaternion.Euler(0f, rotationY, 0f),
				ExitDistance = 2f
			});
		}

		public static bool TryEnterGate(Player player, ArenaGateDefinition gate)
		{
			if (gate == null)
			{
				return false;
			}
			return TryEnterGate(player, gate.GateId, gate.ArenaId);
		}

		public static bool TryEnterGate(Player player, string gateId, string arenaId)
		{
			if (!CanUseVanillaPortal(player) || string.IsNullOrWhiteSpace(gateId) || string.IsNullOrWhiteSpace(arenaId))
			{
				return false;
			}
			if (GateTravelRequested != null)
			{
				return GateTravelRequested(player, gateId, arg3: false);
			}
			ArenaGateDestination arenaGateDestination = EntranceDestinationResolver?.Invoke(gateId);
			if (arenaGateDestination == null || RouteRecorder == null)
			{
				Show(player, "$arenaguard_unconfigured");
				return false;
			}
			PlayerArenaRoute arg = new PlayerArenaRoute
			{
				PlayerId = player.GetPlayerID(),
				ArenaId = arenaId,
				OriginGateId = gateId,
				EnteredUtc = DateTime.UtcNow
			};
			if (!RouteRecorder(arg))
			{
				Show(player, "Arena route could not be saved.");
				return false;
			}
			if (Teleport(player, arenaGateDestination))
			{
				return true;
			}
			RouteRollback?.Invoke(player.GetPlayerID());
			return false;
		}

		public static bool ReturnThroughHubGate(Player player)
		{
			if (!CanUseVanillaPortal(player))
			{
				return false;
			}
			if (GateTravelRequested != null)
			{
				return GateTravelRequested(player, string.Empty, arg3: true);
			}
			ArenaGateDestination arenaGateDestination = ReturnDestinationResolver?.Invoke(player.GetPlayerID());
			if (arenaGateDestination == null)
			{
				Show(player, "Your entrance gate and fallback gate are unavailable.");
				return false;
			}
			if (!Teleport(player, arenaGateDestination))
			{
				return false;
			}
			SuccessfulReturn?.Invoke(player.GetPlayerID());
			return true;
		}

		public static bool CanUseVanillaPortal(Player player)
		{
			if ((Object)(object)player == (Object)null)
			{
				return false;
			}
			ZoneSystem instance = ZoneSystem.instance;
			if ((Object)(object)instance != (Object)null && instance.GetGlobalKey((GlobalKeys)27))
			{
				Show(player, "$msg_blocked");
				return false;
			}
			if ((Object)(object)instance != (Object)null && instance.GetGlobalKey((GlobalKeys)28))
			{
				bool num = (Object)(object)RandEventSystem.instance != (Object)null && !string.IsNullOrEmpty(RandEventSystem.instance.GetBossEvent());
				float num2 = default(float);
				bool flag = instance.GetGlobalKey((GlobalKeys)38, ref num2) && num2 > 0f;
				if (num || flag)
				{
					Show(player, "$msg_blockedbyboss");
					return false;
				}
			}
			if (!((Humanoid)player).IsTeleportable())
			{
				Show(player, "$msg_noteleport");
				return false;
			}
			return true;
		}

		public static void ApplyGateConfiguration(string objectId, string arenaId, string displayName, bool isFallback)
		{
			if (string.IsNullOrWhiteSpace(objectId))
			{
				return;
			}
			ArenaGateBehaviour[] array = Object.FindObjectsByType<ArenaGateBehaviour>((FindObjectsSortMode)0);
			foreach (ArenaGateBehaviour arenaGateBehaviour in array)
			{
				if (arenaGateBehaviour.ObjectId == objectId)
				{
					arenaGateBehaviour.ApplyOwnedConfiguration(arenaId, displayName, isFallback);
					break;
				}
			}
		}

		private static bool Teleport(Player player, ArenaGateDestination destination)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			Quaternion rotation = destination.Rotation;
			float num = ((destination.ExitDistance > 0f) ? destination.ExitDistance : 2f);
			Vector3 val = destination.Position + rotation * Vector3.forward * num + Vector3.up;
			return ((Character)player).TeleportTo(val, rotation, true);
		}

		private static void Show(Player player, string message)
		{
			if (player != null)
			{
				((Character)player).Message((MessageType)2, message, 0, (Sprite)null);
			}
		}
	}
	public sealed class ArenaGateBehaviour : ArenaWorldObjectBehaviour, Hoverable, Interactable, TextReceiver
	{
		public bool IsHubGate;

		public float ActivationRange = 1.5f;

		public float ExitDistance = 2f;

		public Transform ProximityRoot;

		public Color UnconnectedColor = Color.black;

		public Color ConnectedColor = Color.cyan;

		public EffectFade TargetFoundEffect;

		public MeshRenderer Model;

		public EffectList ConnectedEffects;

		private bool _wasConfigured;

		private float _colorAlpha;

		private float _nextStateRefreshTime;

		private float _nextVisualRefreshTime;

		private float _lastVisualRefreshTime;

		private bool _gateColorApplied;

		private readonly MaterialPropertyBlock _modelProperties = new MaterialPropertyBlock();

		protected override void Awake()
		{
			base.Awake();
			if (base.IsOwner)
			{
				NView.GetZDO().Set("arenaguard.is_hub_gate", IsHubGate);
			}
			else if ((Object)(object)NView != (Object)null && NView.IsValid())
			{
				IsHubGate = NView.GetZDO().GetBool("arenaguard.is_hub_gate", IsHubGate);
			}
		}

		public string GetHoverName()
		{
			string text = Read("arenaguard.display_name");
			if (!string.IsNullOrWhiteSpace(text))
			{
				return text;
			}
			if (!IsHubGate)
			{
				return "$arenaguard_entrance_gate";
			}
			return "$arenaguard_hub_gate";
		}

		public string GetHoverText()
		{
			string text = (IsHubGate ? "Return through gate" : "Enter arena");
			string text2 = ArenaWorldObjects.UseKeyLabel();
			string text3 = ArenaWorldObjects.Localize(GetHoverName()) + "\n[<color=yellow><b>" + text2 + "</b></color>] " + text;
			if (ArenaWorldObjects.IsLocalAdmin())
			{
				text3 = text3 + "\n[<color=yellow><b>Shift + " + text2 + "</b></color>] Rename";
			}
			return text3;
		}

		public bool Interact(Humanoid user, bool hold, bool alt)
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			if (hold || (Object)(object)user != (Object)(object)Player.m_localPlayer)
			{
				return false;
			}
			if (alt && ArenaWorldObjects.IsLocalAdmin())
			{
				string arenaId = ArenaWorldObjects.ResolveArenaId(((Component)this).transform.position, base.ArenaId);
				bool isFallback = (Object)(object)NView != (Object)null && NView.IsValid() && NView.GetZDO().GetBool("arenaguard.is_fallback_gate", false);
				ArenaUi.OpenGateAdminPanel(base.ObjectId, arenaId, GetText(), IsHubGate, isFallback);
				return true;
			}
			Player val = (Player)(object)((user is Player) ? user : null);
			if ((Object)(object)val == (Object)null)
			{
				return false;
			}
			return Activate(val);
		}

		public bool Activate(Player player)
		{
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)player == (Object)null || (Object)(object)player != (Object)(object)Player.m_localPlayer || ((Character)player).IsTeleporting())
			{
				return false;
			}
			if (IsHubGate)
			{
				return ArenaTeleporters.ReturnThroughHubGate(player);
			}
			string arenaId = ArenaWorldObjects.ResolveArenaId(((Component)this).transform.position, base.ArenaId);
			return ArenaTeleporters.TryEnterGate(player, base.ObjectId, arenaId);
		}

		private void Update()
		{
			//IL_0183: Unknown result type (might be due to invalid IL or missing references)
			//IL_0189: Unknown result type (might be due to invalid IL or missing references)
			//IL_0194: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			float unscaledTime = Time.unscaledTime;
			if (unscaledTime >= _nextStateRefreshTime)
			{
				_nextStateRefreshTime = unscaledTime + 0.2f;
				bool flag = IsHubGate || !string.IsNullOrWhiteSpace(base.ArenaId);
				if (flag && !_wasConfigured && ConnectedEffects != null && ConnectedEffects.HasEffects())
				{
					ConnectedEffects.Create(((Component)this).transform.position, ((Component)this).transform.rotation, (Transform)null, 1f, -1);
				}
				_wasConfigured = flag;
				if ((Object)(object)TargetFoundEffect != (Object)null)
				{
					Player localPlayer = Player.m_localPlayer;
					bool flag2 = false;
					if ((Object)(object)localPlayer != (Object)null && (Object)(object)ProximityRoot != (Object)null)
					{
						Vector3 val = ((Component)localPlayer).transform.position - ProximityRoot.position;
						flag2 = ((Vector3)(ref val)).sqrMagnitude <= ActivationRange * ActivationRange && ((Humanoid)localPlayer).IsTeleportable();
					}
					TargetFoundEffect.SetActive(flag && flag2);
				}
			}
			float num = (_wasConfigured ? 1f : 0f);
			if (!(unscaledTime < _nextVisualRefreshTime) && (!_gateColorApplied || !Mathf.Approximately(_colorAlpha, num)))
			{
				_nextVisualRefreshTime = unscaledTime + 0.05f;
				float num2 = ((_lastVisualRefreshTime <= 0f) ? 0.05f : (unscaledTime - _lastVisualRefreshTime));
				_lastVisualRefreshTime = unscaledTime;
				_colorAlpha = Mathf.MoveTowards(_colorAlpha, num, num2);
				ApplyGateColor(Color.Lerp(UnconnectedColor, ConnectedColor, _colorAlpha));
			}
		}

		private void ApplyGateColor(Color color)
		{
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)Model == (Object)null))
			{
				_modelProperties.Clear();
				((Renderer)Model).GetPropertyBlock(_modelProperties);
				Material sharedMaterial = ((Renderer)Model).sharedMaterial;
				if ((Object)(object)sharedMaterial != (Object)null && sharedMaterial.HasProperty("_EmissionColor"))
				{
					_modelProperties.SetColor("_EmissionColor", color);
				}
				((Renderer)Model).SetPropertyBlock(_modelProperties);
				_gateColorApplied = true;
			}
		}

		public bool UseItem(Humanoid user, ItemData item)
		{
			return false;
		}

		public string GetText()
		{
			return Read("arenaguard.display_name");
		}

		public void SetText(string text)
		{
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			if (!ArenaWorldObjects.IsLocalAdmin())
			{
				return;
			}
			string text2 = (text ?? string.Empty).Trim();
			if (text2.Length == 0 || text2.Length > 48)
			{
				Player localPlayer = Player.m_localPlayer;
				if (localPlayer != null)
				{
					((Character)localPlayer).Message((MessageType)2, "Gate names must be 1-48 characters.", 0, (Sprite)null);
				}
				return;
			}
			string arg = ArenaWorldObjects.ResolveArenaId(((Component)this).transform.position, base.ArenaId);
			bool arg2 = (Object)(object)NView != (Object)null && NView.IsValid() && NView.GetZDO().GetBool("arenaguard.is_fallback_gate", false);
			if (ArenaTeleporters.GateConfigurationRequested != null)
			{
				ArenaTeleporters.GateConfigurationRequested(base.ObjectId, arg, text2, arg2);
			}
		}

		public void ApplyOwnedConfiguration(string arenaId, string displayName, bool isFallback)
		{
			if (base.IsOwner)
			{
				WriteOwned("arenaguard.arena_id", arenaId);
				WriteOwned("arenaguard.display_name", displayName);
				NView.GetZDO().Set("arenaguard.is_fallback_gate", isFallback);
			}
		}
	}
	public sealed class ArenaGateTrigger : MonoBehaviour
	{
		private ArenaGateBehaviour _gate;

		private void Awake()
		{
			_gate = ((Component)this).GetComponentInParent<ArenaGateBehaviour>();
		}

		private void OnTriggerEnter(Collider colliderIn)
		{
			Player val = (((Object)(object)colliderIn != (Object)null) ? ((Component)colliderIn).GetComponent<Player>() : null);
			if (!((Object)(object)val == (Object)null) && !((Object)(object)val != (Object)(object)Player.m_localPlayer))
			{
				if ((Object)(object)_gate == (Object)null)
				{
					_gate = ((Component)this).GetComponentInParent<ArenaGateBehaviour>();
				}
				_gate?.Activate(val);
			}
		}
	}
	public enum ArenaWorldObjectKind
	{
		Core,
		Sign,
		EntranceGate,
		HubGate,
		StagingMarker,
		CombatantStartMarker,
		EnemySpawnMarker,
		HubGateMarker
	}
	public sealed class ArenaWorldObjectPlacement
	{
		public ArenaWorldObjectKind Kind;

		public string ObjectId;

		public string ArenaId;

		public PositionData Position;

		public float RotationY;
	}
	public static class ArenaWorldObjects
	{
		public const string AdminHammerPrefabName = "ArenaGuard_AdminHammer";

		public const string PieceTableName = "ArenaGuard_PieceTable";

		public const string CorePrefabName = "ArenaGuard_Core";

		public const string ChallengeHostPrefabName = "ArenaGuard_ChallengeHost";

		public const string SignPrefabName = "ArenaGuard_Sign";

		public const string EntranceGatePrefabName = "ArenaGuard_EntranceGate";

		public const string HubGatePrefabName = "ArenaGuard_HubGate";

		public const string StagingMarkerPrefabName = "ArenaGuard_StagingMarker";

		public const string CombatantStartMarkerPrefabName = "ArenaGuard_CombatantStartMarker";

		public const string EnemySpawnMarkerPrefabName = "ArenaGuard_EnemySpawnMarker";

		public const string HubGateMarkerPrefabName = "ArenaGuard_HubGateMarker";

		private const string SignBasePrefabName = "sign";

		private const string ChallengeHostBasePrefabName = "Dverger";

		private const string ChallengeHostIconPrefabName = "TrophyDvergr";

		internal const string ZdoObjectId = "arenaguard.object_id";

		internal const string ZdoArenaId = "arenaguard.arena_id";

		internal const string ZdoDisplayName = "arenaguard.display_name";

		internal const string ZdoPlacementReported = "arenaguard.placement_reported";

		internal const string ZdoMarkerKind = "arenaguard.marker_kind";

		internal const string ZdoMarkerSlot = "arenaguard.marker_slot";

		internal const int MarkerRequestRejected = -2;

		private static bool _registered;

		private static GameObject _adminHammerPrefab;

		private static Player _lastLocalPlayer;

		private static float _nextHammerAuditTime;

		private static float _nextGrantAttemptTime;

		private static bool _adminStatusRefreshSubscribed;

		private static readonly HashSet<int> ChallengeHostCharacterIds = new HashSet<int>();

		public static Func<bool> LocalAdminResolver;

		public static Action<ArenaWorldObjectPlacement> PlacementRequested;

		public static Action<string> CoreRemovalRequested;

		public static Action<string, PositionData> CoreActivated;

		public static Func<string, ArenaMarkerKind, PositionData, int, int> AdminMarkerRequested;

		public static Action<string, ArenaMarkerKind, PositionData, int> AdminMarkerRemovalRequested;

		public static Func<Vector3, string> ArenaAtPositionResolver;

		public static Func<string, ArenaDefinition> ArenaDefinitionResolver;

		public static string SelectedAdminArenaId { get; private set; }

		public static bool AdminSetupVisualsEnabled => ArenaConfig.ShowAdminSetupVisuals?.Value ?? true;

		public static string AdminSetupVisualShortcut
		{
			get
			{
				//IL_000c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0011: Unknown result type (might be due to invalid IL or missing references)
				if (ArenaConfig.ToggleAdminSetupVisualsShortcut != null)
				{
					return ((object)ArenaConfig.ToggleAdminSetupVisualsShortcut.Value/*cast due to .constrained prefix*/).ToString();
				}
				return "F7";
			}
		}

		public static void RegisterPrefabs()
		{
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Expected O, but got Unknown
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Expected O, but got Unknown
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Expected O, but got Unknown
			if (!_registered)
			{
				RequirePieceBasePrefab("guard_stone");
				RequirePieceBasePrefab("sign");
				RequirePieceBasePrefab("portal_wood");
				RequireChallengeHostSources();
				RegisterLocalization();
				PieceTableConfig val = new PieceTableConfig();
				val.UseCategories = true;
				val.UseCustomCategories = true;
				val.CustomCategories = new string[1] { "Arena" };
				val.CanRemovePieces = true;
				CustomPieceTable val2 = new CustomPieceTable("ArenaGuard_PieceTable", val);
				if (!PieceManager.Instance.AddPieceTable(val2))
				{
					throw new InvalidOperationException("ArenaGuard could not register its admin piece table.");
				}
				CustomItem val3 = new CustomItem("ArenaGuard_AdminHammer", "Hammer");
				ConfigureAdminHammer(val3, val2.PieceTable);
				if (!ItemManager.Instance.AddItem(val3))
				{
					throw new InvalidOperationException("ArenaGuard could not register its admin hammer.");
				}
				_adminHammerPrefab = val3.ItemPrefab;
				RegisterCore();
				RegisterChallengeHost();
				RegisterSign(enabled: false);
				RegisterGate("ArenaGuard_EntranceGate", "$arenaguard_entrance_gate", isHub: false);
				RegisterGate("ArenaGuard_HubGate", "$arenaguard_hub_gate", isHub: true);
				RegisterMarker("ArenaGuard_CombatantStartMarker", "$arenaguard_combat_marker", ArenaMarkerKind.CombatantStart);
				RegisterMarker("ArenaGuard_EnemySpawnMarker", "$arenaguard_enemy_marker", ArenaMarkerKind.EnemySpawn);
				TryRegisterCompatibilityMarker("ArenaGuard_StagingMarker", "$arenaguard_staging_marker", ArenaMarkerKind.Staging);
				TryRegisterCompatibilityMarker("ArenaGuard_HubGateMarker", "$arenaguard_hub_marker", ArenaMarkerKind.HubGate);
				_registered = true;
				SubscribeAdminStatusRefresh();
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogInfo((object)"Registered ArenaGuard admin hammer with Arena Core, Arena Master, two gates, and admin-only Combat/Enemy beacons.");
				}
			}
		}

		public static void SelectAdminArena(string arenaId)
		{
			SelectedAdminArenaId = arenaId ?? string.Empty;
		}

		public static bool IsLocalAdmin()
		{
			if (LocalAdminResolver != null && LocalAdminResolver())
			{
				return true;
			}
			if (SynchronizationManager.Instance != null)
			{
				return SynchronizationManager.Instance.PlayerIsAdmin;
			}
			return false;
		}

		internal static bool ShouldShowAdminSetupVisuals()
		{
			if ((Object)(object)Player.m_localPlayer != (Object)null)
			{
				return ArenaAdminVisualPolicy.ShouldShow(IsLocalAdmin(), AdminSetupVisualsEnabled);
			}
			return false;
		}

		public static void HandleAdminVisualToggle()
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			if (ArenaConfig.ToggleAdminSetupVisualsShortcut != null)
			{
				KeyboardShortcut value = ArenaConfig.ToggleAdminSetupVisualsShortcut.Value;
				if (((KeyboardShortcut)(ref value)).IsDown())
				{
					ToggleAdminSetupVisuals();
				}
			}
		}

		public static void ToggleAdminSetupVisuals()
		{
			Player localPlayer = Player.m_localPlayer;
			if (!((Object)(object)localPlayer == (Object)null) && ArenaConfig.ShowAdminSetupVisuals != null)
			{
				if (!IsLocalAdmin())
				{
					((Character)localPlayer).Message((MessageType)2, "Arena setup visuals are waiting for server administrator synchronization.", 0, (Sprite)null);
					return;
				}
				ArenaConfig.ShowAdminSetupVisuals.Value = !ArenaConfig.ShowAdminSetupVisuals.Value;
				RefreshAdminSetupVisuals();
				((Character)localPlayer).Message((MessageType)2, ArenaConfig.ShowAdminSetupVisuals.Value ? "Arena setup visuals shown." : ("Arena setup visuals hidden. Press " + AdminSetupVisualShortcut + " to show them again."), 0, (Sprite)null);
			}
		}

		private static void RefreshAdminSetupVisuals()
		{
			ArenaCoreBehaviour[] array = Object.FindObjectsByType<ArenaCoreBehaviour>((FindObjectsInactive)0, (FindObjectsSortMode)0);
			for (int i = 0; i < array.Length; i++)
			{
				array[i].RefreshAdminVisibility();
			}
			ArenaMarkerBehaviour[] array2 = Object.FindObjectsByType<ArenaMarkerBehaviour>((FindObjectsInactive)0, (FindObjectsSortMode)0);
			for (int i = 0; i < array2.Length; i++)
			{
				array2[i].RefreshAdminVisibility();
			}
		}

		private static void SubscribeAdminStatusRefresh()
		{
			if (!_adminStatusRefreshSubscribed)
			{
				SynchronizationManager.OnAdminStatusChanged += OnAdminStatusChanged;
				_adminStatusRefreshSubscribed = true;
			}
		}

		private static void OnAdminStatusChanged()
		{
			_nextHammerAuditTime = 0f;
			_nextGrantAttemptTime = 0f;
			RefreshAdminSetupVisuals();
		}

		internal static string UseKeyLabel()
		{
			ZInput instance = ZInput.instance;
			string text = ((instance != null) ? instance.GetBoundKeyString("Use", true) : null);
			if (!string.IsNullOrWhiteSpace(text))
			{
				return text;
			}
			return "E";
		}

		internal static string Localize(string text)
		{
			if (Localization.instance != null)
			{
				return Localization.instance.Localize(text);
			}
			return text;
		}

		public static void GrantOrRemoveAdminHammer()
		{
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null || (Object)(object)_adminHammerPrefab == (Object)null)
			{
				return;
			}
			float unscaledTime = Time.unscaledTime;
			if (_lastLocalPlayer == localPlayer && unscaledTime < _nextHammerAuditTime)
			{
				return;
			}
			_lastLocalPlayer = localPlayer;
			_nextHammerAuditTime = unscaledTime + 0.5f;
			if (!IsLocalAdmin())
			{
				RemoveAdminHammer(localPlayer);
				return;
			}
			Inventory inventory = ((Humanoid)localPlayer).GetInventory();
			if (FindAdminHammer(inventory) == null && !(unscaledTime < _nextGrantAttemptTime))
			{
				_nextGrantAttemptTime = unscaledTime + 5f;
				if (!inventory.AddItem(_adminHammerPrefab, 1))
				{
					((Character)localPlayer).Message((MessageType)2, "$arenaguard_hammer_inventory_full", 0, (Sprite)null);
				}
			}
		}

		public static void RemoveAdminHammer(Player player)
		{
			if ((Object)(object)player == (Object)null)
			{
				return;
			}
			Inventory inventory = ((Humanoid)player).GetInventory();
			ItemData val;
			while ((val = FindAdminHammer(inventory)) != null)
			{
				if (((Humanoid)player).IsItemEquiped(val))
				{
					((Humanoid)player).UnequipItem(val, false);
				}
				inventory.RemoveItem(val);
			}
		}

		public static void Shutdown()
		{
			if (_adminStatusRefreshSubscribed)
			{
				SynchronizationManager.OnAdminStatusChanged -= OnAdminStatusChanged;
				_adminStatusRefreshSubscribed = false;
			}
			RemoveAdminHammer(((Object)(object)Player.m_localPlayer != (Object)null) ? Player.m_localPlayer : _lastLocalPlayer);
			_lastLocalPlayer = null;
			_nextHammerAuditTime = 0f;
			_nextGrantAttemptTime = 0f;
			ChallengeHostCharacterIds.Clear();
			SelectedAdminArenaId = string.Empty;
		}

		internal static void TrackChallengeHost(Character character)
		{
			if ((Object)(object)character != (Object)null)
			{
				ChallengeHostCharacterIds.Add(((Object)character).GetInstanceID());
			}
		}

		internal static void ForgetChallengeHost(Character character)
		{
			if ((Object)(object)character != (Object)null)
			{
				ChallengeHostCharacterIds.Remove(((Object)character).GetInstanceID());
			}
		}

		internal static bool IsChallengeHost(Character character)
		{
			if ((Object)(object)character != (Object)null)
			{
				return ChallengeHostCharacterIds.Contains(((Object)character).GetInstanceID());
			}
			return false;
		}

		public static int ApplyAdminMarker(string arenaId, ArenaMarkerKind kind, Vector3 position, int slot = -1)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			if (!IsLocalAdmin() || string.IsNullOrWhiteSpace(arenaId))
			{
				return -2;
			}
			if (AdminMarkerRequested != null)
			{
				return AdminMarkerRequested(arenaId, kind, ToPositionData(position), slot);
			}
			return -2;
		}

		internal static void RemoveAdminMarker(string arenaId, ArenaMarkerKind kind, Vector3 position, int slot)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			if (IsLocalAdmin() && !string.IsNullOrWhiteSpace(arenaId))
			{
				AdminMarkerRemovalRequested?.Invoke(arenaId, kind, ToPositionData(position), slot);
			}
		}

		internal static int ResolveConfiguredEnemySlot(string arenaId, Vector3 position)
		{
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			ArenaDefinition arenaDefinition = ArenaDefinitionResolver?.Invoke(arenaId);
			if (arenaDefinition?.Markers?.EnemySpawnPositions == null)
			{
				return -2;
			}
			for (int i = 0; i < arenaDefinition.Markers.EnemySpawnPositions.Count && i < 4; i++)
			{
				PositionData positionData = arenaDefinition.Markers.EnemySpawnPositions[i];
				if (positionData.X != float.MaxValue || positionData.Y != float.MaxValue || positionData.Z != float.MaxValue)
				{
					float num = positionData.X - position.x;
					float num2 = positionData.Y - position.y;
					float num3 = positionData.Z - position.z;
					if (num * num + num2 * num2 + num3 * num3 <= 0.25f)
					{
						return i;
					}
				}
			}
			return -2;
		}

		public static void OpenArenaSign(string arenaId)
		{
			if (!string.IsNullOrWhiteSpace(arenaId))
			{
				ArenaUi.OpenChallengeMenu(arenaId);
			}
		}

		public static void ApplyArenaConfiguration(string arenaId, string displayName)
		{
			ArenaCoreBehaviour[] array = Object.FindObjectsByType<ArenaCoreBehaviour>((FindObjectsInactive)0, (FindObjectsSortMode)0);
			foreach (ArenaCoreBehaviour arenaCoreBehaviour in array)
			{
				if (string.Equals(arenaCoreBehaviour.ObjectId, arenaId, StringComparison.Ordinal) || string.Equals(arenaCoreBehaviour.ArenaId, arenaId, StringComparison.Ordinal))
				{
					arenaCoreBehaviour.ApplyOwnedDisplayName(displayName);
				}
			}
		}

		internal static string ResolveArenaId(Vector3 position, string current)
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			if (!string.IsNullOrWhiteSpace(current))
			{
				return current;
			}
			if (!string.IsNullOrWhiteSpace(SelectedAdminArenaId))
			{
				return SelectedAdminArenaId;
			}
			return ArenaAtPositionResolver?.Invoke(position) ?? string.Empty;
		}

		internal static void ReportPlacement(ArenaWorldObjectBehaviour worldObject)
		{
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			if (PlacementRequested == null || (Object)(object)worldObject == (Object)null || !worldObject.IsOwner)
			{
				return;
			}
			ZNetView view = worldObject.View;
			ZDO val = (((Object)(object)view != (Object)null) ? view.GetZDO() : null);
			if (val != null && !val.GetBool("arenaguard.placement_reported", false))
			{
				Vector3 worldPosition = worldObject.WorldPosition;
				string text = ((worldObject.Kind == ArenaWorldObjectKind.Core) ? worldObject.ObjectId : ResolveArenaId(worldPosition, worldObject.ArenaId));
				if (!string.IsNullOrWhiteSpace(text) && string.IsNullOrWhiteSpace(worldObject.ArenaId))
				{
					val.Set("arenaguard.arena_id", text);
				}
				PlacementRequested(new ArenaWorldObjectPlacement
				{
					Kind = worldObject.Kind,
					ObjectId = worldObject.ObjectId,
					ArenaId = text,
					Position = ToPositionData(worldPosition),
					RotationY = worldObject.WorldRotationY
				});
				val.Set("arenaguard.placement_reported", true);
			}
		}

		internal static PositionData ToPositionData(Vector3 position)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			return new PositionData
			{
				X = position.x,
				Y = position.y,
				Z = position.z
			};
		}

		internal static Vector3 ToVector3(PositionData position)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			return new Vector3(position.X, position.Y, position.Z);
		}

		private static ItemData FindAdminHammer(Inventory inventory)
		{
			if (inventory == null)
			{
				return null;
			}
			foreach (ItemData allItem in inventory.GetAllItems())
			{
				if ((Object)(object)allItem?.m_dropPrefab != (Object)null && ((Object)allItem.m_dropPrefab).name == "ArenaGuard_AdminHammer")
				{
					return allItem;
				}
			}
			return null;
		}

		private static void ConfigureAdminHammer(CustomItem hammer, PieceTable table)
		{
			if (((hammer == null) ? null : hammer.ItemDrop?.m_itemData?.m_shared) == null)
			{
				throw new InvalidOperationException("The cloned vanilla hammer is missing ItemDrop shared data.");
			}
			SharedData shared = hammer.ItemDrop.m_itemData.m_shared;
			shared.m_name = "$arenaguard_admin_hammer";
			shared.m_description = "$arenaguard_admin_hammer_description";
			shared.m_buildPieces = table;
			shared.m_questItem = true;
			shared.m_teleportable = true;
			shared.m_useDurability = false;
			shared.m_canBeReparied = false;
		}

		private static PieceConfig Piece(string name, string description)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Expected O, but got Unknown
			return new PieceConfig
			{
				Name = name,
				Description = description,
				PieceTable = "ArenaGuard_PieceTable",
				Category = "Arena",
				Enabled = true,
				AllowedInDungeons = false,
				Requirements = Array.Empty<RequirementConfig>()
			};
		}

		private static void RegisterCore()
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Expected O, but got Unknown
			CustomPiece val = new CustomPiece("ArenaGuard_Core", "guard_stone", Piece("$arenaguard_core", "$arenaguard_core_description"));
			RemoveComponent<PrivateArea>(val.PiecePrefab);
			RemoveComponent<EffectArea>(val.PiecePrefab);
			RemoveComponent<Collider>(val.PiecePrefab);
			CreateArenaRadiusRing(val.PiecePrefab.transform, "CombatRadiusRing", new Color(0.05f, 0.75f, 1f, 1f));
			CreateArenaRadiusRing(val.PiecePrefab.transform, "ProtectedRadiusRing", new Color(1f, 0.65f, 0f, 1f));
			SphereCollider val2 = val.PiecePrefab.AddComponent<SphereCollider>();
			val2.center = new Vector3(0f, 1f, 0f);
			val2.radius = 1.25f;
			((Collider)val2).isTrigger = true;
			ValidateCoreInteractionPrefab(expectedBehaviour: AddWorldBehaviour<ArenaCoreBehaviour>(val.PiecePrefab, ArenaWorldObjectKind.Core), prefab: val.PiecePrefab, expectedCollider: val2);
			AddPiece(val);
		}

		private static void CreateArenaRadiusRing(Transform parent, string name, Color color)
		{
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			//IL_015a: Unknown result type (might be due to invalid IL or missing references)
			int num = LayerMask.NameToLayer("piece_nonsolid");
			GameObject prefab = PrefabManager.Instance.GetPrefab("sign");
			Renderer val = (Renderer)(object)((prefab != null) ? ((IEnumerable<MeshRenderer>)prefab.GetComponentsInChildren<MeshRenderer>(true)).FirstOrDefault((Func<MeshRenderer, bool>)delegate(MeshRenderer candidate)
			{
				object obj;
				if (candidate == null)
				{
					obj = null;
				}
				else
				{
					Material sharedMaterial = ((Renderer)candidate).sharedMaterial;
					obj = ((sharedMaterial != null) ? sharedMaterial.shader : null);
				}
				return (Object)obj != (Object)null;
			}) : null);
			if (num < 0 || (Object)(object)((val != null) ? val.sharedMaterial : null) == (Object)null)
			{
				throw new InvalidOperationException("ArenaGuard could not create the admin radius rings.");
			}
			GameObject val2 = new GameObject(name)
			{
				layer = num
			};
			val2.transform.SetParent(parent, false);
			val2.transform.localPosition = new Vector3(0f, 0.2f, 0f);
			val2.transform.localRotation = Quaternion.identity;
			val2.transform.localScale = Vector3.one;
			LineRenderer val3 = val2.AddComponent<LineRenderer>();
			((Renderer)val3).sharedMaterial = val.sharedMaterial;
			val3.useWorldSpace = false;
			val3.loop = true;
			val3.positionCount = 96;
			val3.startWidth = 0.16f;
			val3.endWidth = 0.16f;
			val3.numCornerVertices = 2;
			val3.numCapVertices = 2;
			val3.startColor = color;
			val3.endColor = color;
			((Renderer)val3).enabled = false;
			for (int num2 = 0; num2 < val3.positionCount; num2++)
			{
				float num3 = (float)num2 * (float)Math.PI * 2f / (float)val3.positionCount;
				val3.SetPosition(num2, new Vector3(Mathf.Cos(num3), 0f, Mathf.Sin(num3)));
			}
		}

		private static void ValidateCoreInteractionPrefab(GameObject prefab, ArenaCoreBehaviour expectedBehaviour, SphereCollider expectedCollider)
		{
			if ((Object)(object)prefab.GetComponentInChildren<PrivateArea>(true) != (Object)null || (Object)(object)prefab.GetComponentInChildren<EffectArea>(true) != (Object)null)
			{
				throw new InvalidOperationException("Arena Core prefab retained inherited ward or EffectArea behavior.");
			}
			int num = 0;
			int num2 = 0;
			MonoBehaviour[] componentsInChildren = prefab.GetComponentsInChildren<MonoBehaviour>(true);
			foreach (MonoBehaviour val in componentsInChildren)
			{
				if (val is Hoverable)
				{
					num++;
					if ((object)val != expectedBehaviour)
					{
						throw new InvalidOperationException("Arena Core prefab retained competing Hoverable component '" + ((object)val).GetType().FullName + "'.");
					}
				}
				if (val is Interactable)
				{
					num2++;
					if ((object)val != expectedBehaviour)
					{
						throw new InvalidOperationException("Arena Core prefab retained competing Interactable component '" + ((object)val).GetType().FullName + "'.");
					}
				}
			}
			Collider[] componentsInChildren2 = prefab.GetComponentsInChildren<Collider>(true);
			if (num != 1 || num2 != 1 || componentsInChildren2.Length != 1 || (object)componentsInChildren2[0] != expectedCollider || !((Collider)expectedCollider).isTrigger || (Object)(object)((Component)expectedCollider).gameObject != (Object)(object)((Component)expectedBehaviour).gameObject)
			{
				throw new InvalidOperationException("Arena Core requires one root trigger collider and exactly one shared Hoverable/Interactable handler.");
			}
			ManualLogSource log = Plugin.Log;
			if (log != null)
			{
				log.LogInfo((object)"Validated Arena Core interaction prefab: one root trigger collider and ArenaCoreBehaviour is the sole Hoverable/Interactable.");
			}
		}

		private static void RegisterChallengeHost()
		{
			//IL_018b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0190: Unknown result type (might be due to invalid IL or missing references)
			//IL_0198: Unknown result type (might be due to invalid IL or missing references)
			//IL_01aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01eb: Expected O, but got Unknown
			//IL_0205: Unknown result type (might be due to invalid IL or missing references)
			//IL_021a: Expected O, but got Unknown
			GameObject val = PrefabManager.Instance.CreateClonedPrefab("ArenaGuard_ChallengeHost", "Dverger");
			if ((Object)(object)val == (Object)null)
			{
				throw new InvalidOperationException("ArenaGuard could not clone the installed Dverger rogue prefab.");
			}
			Character component = val.GetComponent<Character>();
			Humanoid component2 = val.GetComponent<Humanoid>();
			ZNetView component3 = val.GetComponent<ZNetView>();
			Rigidbody component4 = val.GetComponent<Rigidbody>();
			BaseAI component5 = val.GetComponent<BaseAI>();
			if ((Object)(object)component == (Object)null || (Object)(object)component2 == (Object)null || (Object)(object)component3 == (Object)null || (Object)(object)component4 == (Object)null || (Object)(object)component5 == (Object)null)
			{
				throw new InvalidOperationException("The installed Dverger rogue prefab is missing its Character, Humanoid, ZNetView, Rigidbody, or AI component.");
			}
			component.m_name = "$arenaguard_challenge_host";
			component.m_aiSkipTarget = true;
			component.m_health = 1000000f;
			((Behaviour)component5).enabled = false;
			component4.isKinematic = true;
			component4.useGravity = false;
			component4.constraints = (RigidbodyConstraints)126;
			component3.m_persistent = true;
			RemoveComponent<CharacterDrop>(val);
			int num = LayerMask.NameToLayer("piece_nonsolid");
			if (num < 0)
			{
				throw new InvalidOperationException("Valheim's piece_nonsolid layer is unavailable.");
			}
			SetLayerRecursively(val, num);
			Collider[] componentsInChildren = val.GetComponentsInChildren<Collider>(true);
			foreach (Collider obj in componentsInChildren)
			{
				obj.enabled = true;
				obj.isTrigger = true;
			}
			Piece obj2 = val.GetComponent<Piece>() ?? val.AddComponent<Piece>();
			GameObject prefab = PrefabManager.Instance.GetPrefab("TrophyDvergr");
			ItemDrop val2 = ((prefab != null) ? prefab.GetComponent<ItemDrop>() : null);
			object icon;
			if (val2 == null)
			{
				icon = null;
			}
			else
			{
				ItemData itemData = val2.m_itemData;
				icon = ((itemData != null) ? itemData.GetIcon() : null);
			}
			obj2.m_icon = (Sprite)icon;
			obj2.m_groundPiece = true;
			obj2.m_groundOnly = true;
			obj2.m_clipGround = true;
			obj2.m_noInWater = true;
			GameObject val3 = new GameObject("ArenaGuard_ChallengeInteraction")
			{
				layer = num
			};
			val3.transform.SetParent(val.transform, false);
			val3.transform.localPosition = new Vector3(0f, 1f, 0f);
			SphereCollider val4 = val3.AddComponent<SphereCollider>();
			val4.radius = 1.15f;
			((Collider)val4).isTrigger = true;
			ArenaChallengeHostBehaviour host = AddWorldBehaviour<ArenaChallengeHostBehaviour>(val3, ArenaWorldObjectKind.Sign);
			val.AddComponent<ArenaChallengeHostRemoval>();
			CustomPiece val5 = new CustomPiece(val, false, Piece("$arenaguard_challenge_host", "$arenaguard_challenge_host_description"));
			ValidateChallengeHostPrefab(val, host, val4);
			AddPiece(val5);
		}

		private static void RegisterSign(bool enabled)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Expected O, but got Unknown
			CustomPiece val = new CustomPiece("ArenaGuard_Sign", "sign", Piece("$arenaguard_sign", "$arenaguard_sign_description"));
			RemoveComponent<Sign>(val.PiecePrefab);
			ValidateSignDerivedPrefab(expectedColliders: MakeSignCollidersNonSolid(val.PiecePrefab), expectedBehaviour: AddWorldBehaviour<ArenaSignBehaviour>(val.PiecePrefab, ArenaWorldObjectKind.Sign), prefab: val.PiecePrefab, displayName: "Arena Challenge Sign");
			AddPiece(val, enabled);
		}

		private static void ValidateChallengeHostPrefab(GameObject prefab, ArenaChallengeHostBehaviour host, SphereCollider interaction)
		{
			Character component = prefab.GetComponent<Character>();
			ZNetView component2 = prefab.GetComponent<ZNetView>();
			Rigidbody component3 = prefab.GetComponent<Rigidbody>();
			BaseAI component4 = prefab.GetComponent<BaseAI>();
			Piece component5 = prefab.GetComponent<Piece>();
			Renderer[] componentsInChildren = prefab.GetComponentsInChildren<Renderer>(true);
			Collider[] componentsInChildren2 = prefab.GetComponentsInChildren<Collider>(true);
			bool flag = componentsInChildren.Length == 0;
			Renderer[] array = componentsInChildren;
			foreach (Renderer val in array)
			{
				flag |= (Object)(object)val == (Object)null || (Object)(object)val.sharedMaterial == (Object)null;
			}
			bool flag2 = componentsInChildren2.Length == 0;
			Collider[] array2 = componentsInChildren2;
			foreach (Collider val2 in array2)
			{
				flag2 |= (Object)(object)val2 == (Object)null || !val2.enabled || !val2.isTrigger;
			}
			if ((Object)(object)component == (Object)null || (Object)(object)component2 == (Object)null || !component2.m_persistent || (Object)(object)component3 == (Object)null || !component3.isKinematic || component3.useGravity || (Object)(object)component4 == (Object)null || ((Behaviour)component4).enabled || (Object)(object)component5 == (Object)null || (Object)(object)component5.m_icon == (Object)null || (Object)(object)host == (Object)null || (Object)(object)interaction == (Object)null || !((Collider)interaction).isTrigger || ((Component)interaction).GetComponent<Interactable>() == null || flag || flag2)
			{
				throw new InvalidOperationException("Arena Master requires a visible Dverger, persistent network state, frozen AI/body, non-solid colliders, and one interaction bubble.");
			}
			ManualLogSource log = Plugin.Log;
			if (log != null)
			{
				log.LogInfo((object)("Validated stationary Arena Master Dvergr: renderers=" + componentsInChildren.Length + ", colliders=" + componentsInChildren2.Length + ", persistent=True, aiDisabled=True, nonSolid=True."));
			}
		}

		private static void RegisterGate(string prefabName, string displayName, bool isHub)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Expected O, but got Unknown
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			CustomPiece val = new CustomPiece(prefabName, "portal_wood", Piece(displayName, "$arenaguard_gate_description"));
			TeleportWorld component = val.PiecePrefab.GetComponent<TeleportWorld>();
			ArenaGateBehaviour arenaGateBehaviour = AddWorldBehaviour<ArenaGateBehaviour>(val.PiecePrefab, isHub ? ArenaWorldObjectKind.HubGate : ArenaWorldObjectKind.EntranceGate);
			arenaGateBehaviour.IsHubGate = isHub;
			if ((Object)(object)component != (Object)null)
			{
				arenaGateBehaviour.ActivationRange = component.m_activationRange;
				arenaGateBehaviour.ExitDistance = component.m_exitDistance;
				arenaGateBehaviour.ProximityRoot = component.m_proximityRoot;
				arenaGateBehaviour.UnconnectedColor = component.m_colorUnconnected;
				arenaGateBehaviour.ConnectedColor = component.m_colorTargetfound;
				arenaGateBehaviour.TargetFoundEffect = component.m_target_found;
				arenaGateBehaviour.Model = component.m_model;
				arenaGateBehaviour.ConnectedEffects = component.m_connected;
			}
			ReplacePortalTriggers(val.PiecePrefab);
			RemoveComponent<TeleportWorld>(val.PiecePrefab);
			AddPiece(val);
		}

		private static void ReplacePortalTriggers(GameObject prefab)
		{
			TeleportWorldTrigger[] componentsInChildren = prefab.GetComponentsInChildren<TeleportWorldTrigger>(true);
			foreach (TeleportWorldTrigger val in componentsInChildren)
			{
				if ((Object)(object)((Component)val).GetComponent<ArenaGateTrigger>() == (Object)null)
				{
					((Component)val).gameObject.AddComponent<ArenaGateTrigger>();
				}
				Object.DestroyImmediate((Object)(object)val);
			}
		}

		private static void RegisterMarker(string prefabName, string displayName, ArenaMarkerKind markerKind, bool enabled = true)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: Unknown result type (might be due to invalid IL or missing references)
			//IL_013f: Unknown result type (might be due to invalid IL or missing references)
			//IL_016b: Expected O, but got Unknown
			CustomPiece val = new CustomPiece(prefabName, true, Piece(displayName, markerKind switch
			{
				ArenaMarkerKind.EnemySpawn => "$arenaguard_enemy_marker_description", 
				ArenaMarkerKind.CombatantStart => "$arenaguard_combat_marker_description", 
				_ => "$arenaguard_marker_description", 
			}));
			GameObject piecePrefab = val.PiecePrefab;
			if ((Object)(object)piecePrefab == (Object)null)
			{
				throw new InvalidOperationException("ArenaGuard could not create marker prefab " + prefabName + ".");
			}
			int num = LayerMask.NameToLayer("piece_nonsolid");
			if (num < 0)
			{
				throw new InvalidOperationException("Valheim's piece_nonsolid layer is unavailable.");
			}
			SetLayerRecursively(piecePrefab, num);
			Piece component = piecePrefab.GetComponent<Piece>();
			GameObject prefab = PrefabManager.Instance.GetPrefab("TrophyDvergr");
			ItemDrop val2 = ((prefab != null) ? prefab.GetComponent<ItemDrop>() : null);
			if ((Object)(object)component == (Object)null)
			{
				throw new InvalidOperationException("ArenaGuard marker prefab has no Piece component.");
			}
			object icon;
			if (val2 == null)
			{
				icon = null;
			}
			else
			{
				ItemData itemData = val2.m_itemData;
				icon = ((itemData != null) ? itemData.GetIcon() : null);
			}
			component.m_icon = (Sprite)icon;
			component.m_groundPiece = true;
			component.m_groundOnly = true;
			component.m_clipGround = true;
			component.m_noInWater = false;
			ZNetView component2 = piecePrefab.GetComponent<ZNetView>();
			if ((Object)(object)component2 != (Object)null)
			{
				component2.m_persistent = true;
			}
			RemoveComponent<Collider>(piecePrefab);
			CreateMarkerVisuals(piecePrefab, markerKind, num);
			SphereCollider val3 = piecePrefab.AddComponent<SphereCollider>();
			val3.center = new Vector3(0f, 1f, 0f);
			val3.radius = 0.85f;
			((Collider)val3).isTrigger = true;
			ArenaMarkerBehaviour arenaMarkerBehaviour = AddWorldBehaviour<ArenaMarkerBehaviour>(val.PiecePrefab, MarkerObjectKind(markerKind));
			arenaMarkerBehaviour.MarkerKind = markerKind;
			ValidateMarkerPrefab(piecePrefab, arenaMarkerBehaviour, val3, displayName);
			AddPiece(val, enabled);
		}

		private static void TryRegisterCompatibilityMarker(string prefabName, string displayName, ArenaMarkerKind markerKind)
		{
			try
			{
				RegisterMarker(prefabName, displayName, markerKind, enabled: false);
			}
			catch (Exception ex)
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogWarning((object)("Could not register hidden compatibility marker '" + prefabName + "'. Combat Start and Enemy Spawn remain available. " + ex));
				}
			}
		}

		private static void CreateMarkerVisuals(GameObject prefab, ArenaMarkerKind markerKind, int layer)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			CreateMarkerPrimitive(prefab.transform, (PrimitiveType)2, "FloorRing", new Vector3(0f, 0.04f, 0f), new Vector3(1.35f, 0.04f, 1.35f), layer);
			CreateMarkerPrimitive(prefab.transform, (PrimitiveType)2, "BeaconPost", new Vector3(0f, 0.9f, 0f), new Vector3(0.08f, 0.9f, 0.08f), layer);
			CreateMarkerPrimitive(prefab.transform, (PrimitiveType)0, "BeaconTop", new Vector3(0f, 1.85f, 0f), new Vector3(0.32f, 0.32f, 0.32f), layer);
		}

		internal static Color MarkerColor(ArenaMarkerKind markerKind)
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			return (Color)(markerKind switch
			{
				ArenaMarkerKind.CombatantStart => new Color(0.05f, 0.75f, 1f, 1f), 
				ArenaMarkerKind.EnemySpawn => new Color(1f, 0f, 0f, 1f), 
				ArenaMarkerKind.HubGate => new Color(1f, 0.7f, 0f, 1f), 
				_ => new Color(0.2f, 1f, 0.25f, 1f), 
			});
		}

		private static void CreateMarkerPrimitive(Transform parent, PrimitiveType type, string name, Vector3 localPosition, Vector3 localScale, int layer)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			GameObject obj = GameObject.CreatePrimitive(type);
			((Object)obj).name = name;
			obj.layer = layer;
			obj.transform.SetParent(parent, false);
			obj.transform.localPosition = localPosition;
			obj.transform.localRotation = Quaternion.identity;
			obj.transform.localScale = localScale;
			Collider component = obj.GetComponent<Collider>();
			if ((Object)(object)component != (Object)null)
			{
				Object.DestroyImmediate((Object)(object)component);
			}
			Renderer component2 = obj.GetComponent<Renderer>();
			GameObject prefab = PrefabManager.Instance.GetPrefab("sign");
			Renderer val = (Renderer)(object)((prefab != null) ? ((IEnumerable<MeshRenderer>)prefab.GetComponentsInChildren<MeshRenderer>(true)).FirstOrDefault((Func<MeshRenderer, bool>)delegate(MeshRenderer candidate)
			{
				object obj2;
				if (candidate == null)
				{
					obj2 = null;
				}
				else
				{
					Material sharedMaterial = ((Renderer)candidate).sharedMaterial;
					obj2 = ((sharedMaterial != null) ? sharedMaterial.shader : null);
				}
				return (Object)obj2 != (Object)null;
			}) : null);
			if ((Object)(object)component2 == (Object)null || (Object)(object)((val != null) ? val.sharedMaterial : null) == (Object)null)
			{
				throw new InvalidOperationException("ArenaGuard could not resolve a Valheim marker material.");
			}
			int count = Math.Max(1, component2.sharedMaterials.Length);
			component2.sharedMaterials = Enumerable.Repeat<Material>(val.sharedMaterial, count).ToArray();
		}

		private static void ValidateMarkerPrefab(GameObject prefab, ArenaMarkerBehaviour expectedBehaviour, SphereCollider expectedCollider, string displayName)
		{
			Collider[] componentsInChildren = prefab.GetComponentsInChildren<Collider>(true);
			Renderer[] componentsInChildren2 = prefab.GetComponentsInChildren<Renderer>(true);
			Piece component = prefab.GetComponent<Piece>();
			ZNetView component2 = prefab.GetComponent<ZNetView>();
			int num = prefab.GetComponentsInChildren<MonoBehaviour>(true).Count((MonoBehaviour val) => val is Hoverable);
			int num2 = prefab.GetComponentsInChildren<MonoBehaviour>(true).Count((MonoBehaviour val) => val is Interactable);
			List<string> list = new List<string>();
			if ((Object)(object)component == (Object)null || (Object)(object)component.m_icon == (Object)null)
			{
				list.Add("build Piece/icon");
			}
			if ((Object)(object)component2 == (Object)null || !component2.m_persistent)
			{
				list.Add("persistent ZNetView");
			}
			if ((Object)(object)expectedBehaviour == (Object)null)
			{
				list.Add("ArenaMarkerBehaviour");
			}
			if (componentsInChildren.Length != 1 || (object)componentsInChildren.FirstOrDefault() != expectedCollider || (Object)(object)expectedCollider == (Object)null || !((Collider)expectedCollider).isTrigger)
			{
				list.Add("one trigger-only selection collider");
			}
			if (componentsInChildren2.Length != 3 || componentsInChildren2.Any((Renderer renderer) => (Object)(object)renderer == (Object)null || (Object)(object)renderer.sharedMaterial == (Object)null))
			{
				list.Add("three initialized beacon renderers");
			}
			if (num != 1 || num2 != 1)
			{
				list.Add("one Hoverable/Interactable handler");
			}
			if (list.Count != 0)
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogWarning((object)(displayName + " marker validation warning: " + string.Join(", ", list) + ". Registration will continue."));
				}
				return;
			}
			ManualLogSource log2 = Plugin.Log;
			if (log2 != null)
			{
				log2.LogInfo((object)("Validated admin-only non-solid " + displayName + ": renderers=" + componentsInChildren2.Length + ", colliders=1."));
			}
		}

		private static Collider[] MakeSignCollidersNonSolid(GameObject prefab)
		{
			Collider[] componentsInChildren = prefab.GetComponentsInChildren<Collider>(true);
			if (componentsInChildren.Length == 0)
			{
				throw new InvalidOperationException("The Valheim sign source has no selection collider.");
			}
			Collider[] array = componentsInChildren;
			foreach (Collider obj in array)
			{
				obj.enabled = true;
				obj.isTrigger = true;
			}
			return componentsInChildren;
		}

		private static void ValidateSignDerivedPrefab(GameObject prefab, ArenaWorldObjectBehaviour expectedBehaviour, Collider[] expectedColliders, string displayName)
		{
			//IL_019e: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ac: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			int num2 = 0;
			MonoBehaviour[] componentsInChildren = prefab.GetComponentsInChildren<MonoBehaviour>(true);
			foreach (MonoBehaviour val in componentsInChildren)
			{
				if (val is Hoverable)
				{
					num++;
					if ((object)val != expectedBehaviour)
					{
						throw new InvalidOperationException(displayName + " retained competing Hoverable component '" + ((object)val).GetType().FullName + "'.");
					}
				}
				if (val is Interactable)
				{
					num2++;
					if ((object)val != expectedBehaviour)
					{
						throw new InvalidOperationException(displayName + " retained competing Interactable component '" + ((object)val).GetType().FullName + "'.");
					}
				}
			}
			Collider[] componentsInChildren2 = prefab.GetComponentsInChildren<Collider>(true);
			Renderer[] componentsInChildren3 = prefab.GetComponentsInChildren<Renderer>(true);
			MeshFilter[] componentsInChildren4 = prefab.GetComponentsInChildren<MeshFilter>(true);
			bool flag = componentsInChildren2.Length == 0 || expectedColliders == null || componentsInChildren2.Length != expectedColliders.Length;
			Collider[] array = componentsInChildren2;
			foreach (Collider val2 in array)
			{
				flag |= (Object)(object)val2 == (Object)null || !val2.enabled || !val2.isTrigger;
			}
			bool flag2 = componentsInChildren3.Length == 0 || componentsInChildren4.Length == 0;
			Renderer[] array2 = componentsInChildren3;
			foreach (Renderer val3 in array2)
			{
				flag2 |= (Object)(object)val3 == (Object)null || !val3.enabled || val3.forceRenderingOff || !((Component)val3).gameObject.activeSelf || (Object)(object)val3.sharedMaterial == (Object)null;
			}
			MeshFilter[] array3 = componentsInChildren4;
			foreach (MeshFilter val4 in array3)
			{
				bool num3 = flag2;
				int num4;
				if (!((Object)(object)val4 == (Object)null) && !((Object)(object)val4.sharedMesh == (Object)null))
				{
					Bounds bounds = val4.sharedMesh.bounds;
					Vector3 size = ((Bounds)(ref bounds)).size;
					num4 = ((((Vector3)(ref size)).sqrMagnitude <= 0.0001f) ? 1 : 0);
				}
				else
				{
					num4 = 1;
				}
				flag2 = (byte)((num3 ? 1u : 0u) | (uint)num4) != 0;
			}
			if (num != 1 || num2 != 1 || flag || flag2)
			{
				throw new InvalidOperationException(displayName + " requires visible mesh/material data, preserved trigger colliders, and one interaction handler.");
			}
			ManualLogSource log = Plugin.Log;
			if (log != null)
			{
				log.LogInfo((object)("Validated visible non-solid " + displayName + ": renderers=" + componentsInChildren3.Length + ", meshes=" + componentsInChildren4.Length + ", colliders=" + componentsInChildren2.Length + "."));
			}
		}

		private static T AddWorldBehaviour<T>(GameObject prefab, ArenaWorldObjectKind kind) where T : ArenaWorldObjectBehaviour
		{
			T obj = prefab.GetComponent<T>() ?? prefab.AddComponent<T>();
			obj.Kind = kind;
			return obj;
		}

		private static void SetLayerRecursively(GameObject root, int layer)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			root.layer = layer;
			foreach (Transform item in root.transform)
			{
				SetLayerRecursively(((Component)item).gameObject, layer);
			}
		}

		private static ArenaWorldObjectKind MarkerObjectKind(ArenaMarkerKind markerKind)
		{
			return markerKind switch
			{
				ArenaMarkerKind.Staging => ArenaWorldObjectKind.StagingMarker, 
				ArenaMarkerKind.CombatantStart => ArenaWorldObjectKind.CombatantStartMarker, 
				ArenaMarkerKind.EnemySpawn => ArenaWorldObjectKind.EnemySpawnMarker, 
				_ => ArenaWorldObjectKind.HubGateMarker, 
			};
		}

		private static void AddPiece(CustomPiece piece, bool enabled = true)
		{
			if ((Object)(object)((piece != null) ? piece.PiecePrefab : null) == (Object)null)
			{
				throw new InvalidOperationException("ArenaGuard received an empty custom piece prefab during registration.");
			}
			if ((Object)(object)piece.Piece == (Object)null)
			{
				throw new InvalidOperationException("ArenaGuard piece '" + ((Object)piece.PiecePrefab).name + "' has no Piece component.");
			}
			if ((Object)(object)piece.Piece.m_icon == (Object)null)
			{
				throw new InvalidOperationException("ArenaGuard piece '" + ((Object)piece.PiecePrefab).name + "' has no build-menu icon.");
			}
			if (string.IsNullOrWhiteSpace(piece.Piece.m_name) || string.IsNullOrWhiteSpace(piece.Piece.m_description))
			{
				throw new InvalidOperationException("ArenaGuard piece '" + ((Object)piece.PiecePrefab).name + "' has incomplete build-menu name or description metadata.");
			}
			piece.Piece.m_enabled = enabled;
			piece.Piece.m_canBeRemoved = true;
			piece.Piece.m_resources = Array.Empty<Requirement>();
			piece.Piece.m_craftingStation = null;
			piece.Piece.m_onlyInTeleportArea = false;
			piece.Piece.m_cultivatedGroundOnly = false;
			piece.Piece.m_notOnFloor = false;
			piece.Piece.m_inCeilingOnly = false;
			piece.Piece.m_noClipping = false;
			piece.Piece.m_spaceRequirement = 0f;
			piece.Piece.m_mustConnectTo = null;
			piece.Piece.m_blockingPieces?.Clear();
			if (!PieceManager.Instance.AddPiece(piece))
			{
				throw new InvalidOperationException("ArenaGuard could not register piece " + ((Object)piece.PiecePrefab).name + ".");
			}
			piece.Piece.m_enabled = enabled;
			ManualLogSource log = Plugin.Log;
			if (log != null)
			{
				log.LogInfo((object)("Registered ArenaGuard build piece '" + ((Object)piece.PiecePrefab).name + "' (" + piece.Piece.m_name + ")."));
			}
		}

		private static void RequirePieceBasePrefab(string prefabName)
		{
			GameObject prefab = PrefabManager.Instance.GetPrefab(prefabName);
			Piece val = (((Object)(object)prefab == (Object)null) ? null : prefab.GetComponent<Piece>());
			if ((Object)(object)prefab == (Object)null || (Object)(object)val == (Object)null)
			{
				throw new InvalidOperationException("ArenaGuard requires the installed Valheim piece prefab '" + prefabName + "', but it was not available.");
			}
			if ((Object)(object)val.m_icon == (Object)null)
			{
				throw new InvalidOperationException("Valheim piece prefab '" + prefabName + "' has no icon for ArenaGuard to inherit.");
			}
		}

		private static void RequireChallengeHostSources()
		{
			GameObject prefab = PrefabManager.Instance.GetPrefab("Dverger");
			GameObject prefab2 = PrefabManager.Instance.GetPrefab("TrophyDvergr");
			if ((Object)(object)prefab == (Object)null || (Object)(object)prefab.GetComponent<Character>() == (Object)null || (Object)(object)prefab.GetComponent<Humanoid>() == (Object)null || (Object)(object)prefab.GetComponent<ZNetView>() == (Object)null || (Object)(object)prefab.GetComponent<Rigidbody>() == (Object)null || (Object)(object)prefab.GetComponent<BaseAI>() == (Object)null)
			{
				throw new InvalidOperationException("ArenaGuard requires the installed Valheim Dverger rogue prefab with its standard character components.");
			}
			object obj;
			if (prefab2 == null)
			{
				obj = null;
			}
			else
			{
				ItemDrop component = prefab2.GetComponent<ItemDrop>();
				if (component == null)
				{
					obj = null;
				}
				else
				{
					ItemData itemData = component.m_itemData;
					obj = ((itemData != null) ? itemData.GetIcon() : null);
				}
			}
			if ((Object)obj == (Object)null)
			{
				throw new InvalidOperationException("ArenaGuard requires the installed TrophyDvergr prefab for the Arena Master build icon.");
			}
		}

		private static void RemoveComponent<T>(GameObject prefab) where T : Component
		{
			T[] componentsInChildren = prefab.GetComponentsInChildren<T>(true);
			for (int i = 0; i < componentsInChildren.Length; i++)
			{
				Object.DestroyImmediate((Object)(object)componentsInChildren[i]);
			}
		}

		private static void RegisterLocalization()
		{
			Dictionary<string, string> dictionary = new Dictionary<string, string>
			{
				["arenaguard_admin_hammer"] = "Arena Admin Hammer",
				["arenaguard_admin_hammer_description"] = "Admin-only tool for placing and configuring arenas.",
				["arenaguard_hammer_inventory_full"] = "Make one inventory space for the Arena Admin Hammer.",
				["arenaguard_core"] = "Arena Core",
				["arenaguard_core_description"] = "Defines an administrator-managed protected arena.",
				["arenaguard_sign"] = "Arena Challenge Sign",
				["arenaguard_sign_description"] = "Choose a challenge or view the server leaderboard.",
				["arenaguard_challenge_host"] = "Arena Master",
				["arenaguard_challenge_host_description"] = "Talk to this named Dvergr rogue to choose a challenge or view the server leaderboard.",
				["arenaguard_entrance_gate"] = "Arena Gate",
				["arenaguard_hub_gate"] = "Arena Return Gate",
				["arenaguard_gate_description"] = "A named SkaldHall portal which preserves vanilla teleport restrictions.",
				["arenaguard_staging_marker"] = "Staging Position",
				["arenaguard_combat_marker"] = "Combat Start Position",
				["arenaguard_enemy_marker"] = "Enemy Spawn Position",
				["arenaguard_hub_marker"] = "Hub Gate Position",
				["arenaguard_marker_description"] = "Place this marker with the Arena Admin Hammer.",
				["arenaguard_combat_marker_description"] = "Admin-only cyan beacon for the combatant's starting point. Place exactly one.",
				["arenaguard_enemy_marker_description"] = "Admin-only red enemy spawn beacon. Place four; they number themselves automatically.",
				["arenaguard_admin_only"] = "Only a server administrator can use this.",
				["arenaguard_admin_build_only"] = "Only an authorized arena administrator may build or demolish here.",
				["arenaguard_unconfigured"] = "This arena object has not been configured yet.",
				["arenaguard_gate_name_topic"] = "Unique gate name"
			};
			string text = "English";
			LocalizationManager.Instance.GetLocalization().AddTranslation(ref text, dictionary);
		}
	}
	public abstract class ArenaWorldObjectBehaviour : MonoBehaviour
	{
		public ArenaWorldObjectKind Kind;

		protected ZNetView NView;

		public ZNetView View => NView;

		public bool IsOwner
		{
			get
			{
				if ((Object)(object)NView != (Object)null && NView.IsValid())
				{
					return NView.IsOwner();
				}
				return false;
			}
		}

		public string ObjectId => GetOrCreateObjectId();

		public string ArenaId => Read(ZdoArenaId);

		public virtual Vector3 WorldPosition => ((Component)this).transform.position;

		public virtual float WorldRotationY => ((Component)this).transform.eulerAngles.y;

		protected static string ZdoArenaId => "arenaguard.arena_id";

		protected virtual void Awake()
		{
			NView = ((Component)this).GetComponent<ZNetView>() ?? ((Component)this).GetComponentInParent<ZNetView>();
			GetOrCreateObjectId();
		}

		protected virtual void Start()
		{
			ArenaWorldObjects.ReportPlacement(this);
		}

		protected string Read(string key)
		{
			ZDO obj = (((Object)(object)NView != (Object)null) ? NView.GetZDO() : null);
			return ((obj != null) ? obj.GetString(key, string.Empty) : null) ?? string.Empty;
		}

		protected int ReadInt(string key, int fallback)
		{
			ZDO obj = (((Object)(object)NView != (Object)null) ? NView.GetZDO() : null);
			if (obj == null)
			{
				return fallback;
			}
			return obj.GetInt(key, fallback);
		}

		protected bool ReadBool(string key, bool fallback)
		{
			ZDO obj = (((Object)(object)NView != (Object)null) ? NView.GetZDO() : null);
			if (obj == null)
			{
				return fallback;
			}
			return obj.GetBool(key, fallback);
		}

		protected void WriteOwned(string key, string value)
		{
			if (IsOwner)
			{
				NView.GetZDO().Set(key, value ?? string.Empty);
			}
		}

		protected void WriteOwned(string key, int value)
		{
			if (IsOwner)
			{
				NView.GetZDO().Set(key, value);
			}
		}

		private string GetOrCreateObjectId()
		{
			string text = Read("arenaguard.object_id");
			if (string.IsNullOrWhiteSpace(text) && IsOwner)
			{
				text = Guid.NewGuid().ToString("N").ToLowerInvariant();
				WriteOwned("arenaguard.object_id", text);
			}
			return text;
		}
	}
	public sealed class ArenaCoreBehaviour : ArenaWorldObjectBehaviour, Hoverable, Interactable, IRemoved
	{
		private static readonly Color CombatRadiusColor = new Color(0.05f, 0.75f, 1f, 1f);

		private static readonly Color ProtectedRadiusColor = new Color(1f, 0.65f, 0f, 1f);

		private Renderer[] _renderers = Array.Empty<Renderer>();

		private Projector[] _projectors = Array.Empty<Projector>();

		private Light[] _lights = Array.Empty<Light>();

		private LightFlicker[] _lightFlickers = Array.Empty<LightFlicker>();

		private LightLod[] _lightLods = Array.Empty<LightLod>();

		private AudioSource[] _audioSources = Array.Empty<AudioSource>();

		private SphereCollider _interactionCollider;

		private LineRenderer _combatRadiusRing;

		private LineRenderer _protectedRadiusRing;

		private readonly MaterialPropertyBlock _combatRadiusProperties = new MaterialPropertyBlock();

		private readonly MaterialPropertyBlock _protectedRadiusProperties = new MaterialPropertyBlock();

		private float _renderedCombatRadius = float.NaN;

		private float _renderedProtectedRadius = float.NaN;

		private bool _combatRadiusStyleApplied;

		private bool _protectedRadiusStyleApplied;

		private float _nextVisibilityRefresh;

		protected override void Awake()
		{
			base.Awake();
			_renderers = ((Component)this).GetComponentsInChildren<Renderer>(true);
			_projectors = ((Component)this).GetComponentsInChildren<Projector>(true);
			_lights = ((Component)this).GetComponentsInChildren<Light>(true);
			_lightFlickers = ((Component)this).GetComponentsInChildren<LightFlicker>(true);
			_lightLods = ((Component)this).GetComponentsInChildren<LightLod>(true);
			_audioSources = ((Component)this).GetComponentsInChildren<AudioSource>(true);
			_interactionCollider = ((Component)this).GetComponent<SphereCollider>();
			_combatRadiusRing = ((IEnumerable<LineRenderer>)((Component)this).GetComponentsInChildren<LineRenderer>(true)).FirstOrDefault((Func<LineRenderer, bool>)((LineRenderer candidate) => ((Object)candidate).name == "CombatRadiusRing"));
			_protectedRadiusRing = ((IEnumerable<LineRenderer>)((Component)this).GetComponentsInChildren<LineRenderer>(true)).FirstOrDefault((Func<LineRenderer, bool>)((LineRenderer candidate) => ((Object)candidate).name == "ProtectedRadiusRing"));
			if ((Object)(object)Player.m_localPlayer != (Object)null)
			{
				ApplyAdminVisibility();
			}
		}

		protected override void Start()
		{
			base.Start();
			ApplyAdminVisibility();
		}

		private void Update()
		{
			if (!(Time.unscaledTime < _nextVisibilityRefresh))
			{
				_nextVisibilityRefresh = Time.unscaledTime + 0.5f;
				ApplyAdminVisibility();
			}
		}

		private void ApplyAdminVisibility()
		{
			bool flag = ArenaWorldObjects.ShouldShowAdminSetupVisuals();
			Renderer[] renderers = _renderers;
			foreach (Renderer val in renderers)
			{
				if ((Object)(object)val != (Object)null)
				{
					val.enabled = flag;
				}
			}
			Projector[] projectors = _projectors;
			foreach (Projector val2 in projectors)
			{
				if ((Object)(object)val2 != (Object)null)
				{
					((Behaviour)val2).enabled = flag;
				}
			}
			LightFlicker[] lightFlickers = _lightFlickers;
			foreach (LightFlicker val3 in lightFlickers)
			{
				if ((Object)(object)val3 != (Object)null)
				{
					((Behaviour)val3).enabled = flag;
				}
			}
			LightLod[] lightLods = _lightLods;
			foreach (LightLod val4 in lightLods)
			{
				if ((Object)(object)val4 != (Object)null)
				{
					((Behaviour)val4).enabled = flag;
				}
			}
			Light[] lights = _lights;
			foreach (Light val5 in lights)
			{
				if ((Object)(object)val5 != (Object)null)
				{
					((Behaviour)val5).enabled = flag;
					if (!flag)
					{
						val5.intensity = 0f;
						val5.range = 0f;
					}
				}
			}
			AudioSource[] audioSources = _audioSources;
			foreach (AudioSource val6 in audioSources)
			{
				if ((Object)(object)val6 != (Object)null)
				{
					((Behaviour)val6).enabled = flag;
				}
			}
			if ((Object)(object)_interactionCollider != (Object)null)
			{
				((Collider)_interactionCollider).isTrigger = true;
				((Collider)_interactionCollider).enabled = flag;
			}
			ApplyRadiusRingVisibility(flag);
		}

		internal void RefreshAdminVisibility()
		{
			ApplyAdminVisibility();
		}

		private void ApplyRadiusRingVisibility(bool adminVisible)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			string text = ResolveCanonicalArenaId();
			if (string.IsNullOrWhiteSpace(text))
			{
				text = ArenaWorldObjects.ArenaAtPositionResolver?.Invoke(((Component)this).transform.position) ?? string.Empty;
			}
			ArenaDefinition arenaDefinition = (string.IsNullOrWhiteSpace(text) ? null : ArenaWorldObjects.ArenaDefinitionResolver?.Invoke(text));
			ApplyRadiusRing(_combatRadiusRing, arenaDefinition?.CombatRadius ?? 0f, CombatRadiusColor, adminVisible && arenaDefinition != null, _combatRadiusProperties, ref _renderedCombatRadius, ref _combatRadiusStyleApplied);
			ApplyRadiusRing(_protectedRadiusRing, arenaDefinition?.ProtectedRadius ?? 0f, ProtectedRadiusColor, adminVisible && arenaDefinition != null, _protectedRadiusProperties, ref _renderedProtectedRadius, ref _protectedRadiusStyleApplied);
		}

		private static void ApplyRadiusRing(LineRenderer ring, float radius, Color color, bool visible, MaterialPropertyBlock properties, ref float renderedRadius, ref bool styleApplied)
		{
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0128: Unknown result type (might be due to invalid IL or missing references)
			//IL_014b: Unknown result type (might be due to invalid IL or missing references)
			//IL_016e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0174: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)ring == (Object)null)
			{
				return;
			}
			bool flag = !float.IsNaN(radius) && !float.IsInfinity(radius) && radius > 0f;
			((Renderer)ring).enabled = visible && flag;
			if (!((Renderer)ring).enabled)
			{
				return;
			}
			if (float.IsNaN(renderedRadius) || !Mathf.Approximately(renderedRadius, radius))
			{
				for (int i = 0; i < ring.positionCount; i++)
				{
					float num = (float)i * (float)Math.PI * 2f / (float)ring.positionCount;
					ring.SetPosition(i, new Vector3(Mathf.Cos(num) * radius, 0f, Mathf.Sin(num) * radius));
				}
				renderedRadius = radius;
			}
			if (!styleApplied)
			{
				ring.startColor = color;
				ring.endColor = color;
				((Renderer)ring).GetPropertyBlock(properties);
				Material sharedMaterial = ((Renderer)ring).sharedMaterial;
				if ((Object)(object)sharedMaterial != (Object)null && sharedMaterial.HasProperty("_MainTex"))
				{
					properties.SetTexture("_MainTex", (Texture)(object)Texture2D.whiteTexture);
				}
				if ((Object)(object)sharedMaterial != (Object)null && sharedMaterial.HasProperty("_BaseMap"))
				{
					properties.SetTexture("_BaseMap", (Texture)(object)Texture2D.whiteTexture);
				}
				if ((Object)(object)sharedMaterial != (Object)null && sharedMaterial.HasProperty("_Color"))
				{
					properties.SetColor("_Color", color);
				}
				if ((Object)(object)sharedMaterial != (Object)null && sharedMaterial.HasProperty("_BaseColor"))
				{
					properties.SetColor("_BaseColor", color);
				}
				if ((Object)(object)sharedMaterial != (Object)null && sharedMaterial.HasProperty("_EmissionColor"))
				{
					properties.SetColor("_EmissionColor", color * 1.25f);
				}
				((Renderer)ring).SetPropertyBlock(properties);
				styleApplied = true;
			}
		}

		public string GetHoverName()
		{
			if (!ArenaWorldObjects.IsLocalAdmin())
			{
				return string.Empty;
			}
			string text = Read("arenaguard.display_name");
			return ArenaWorldObjects.Localize(string.IsNullOrWhiteSpace(text) ? "$arenaguard_core" : text);
		}

		public string GetHoverText()
		{
			if (!ArenaWorldObjects.IsLocalAdmin())
			{
				return string.Empty;
			}
			return GetHoverName() + "\n[<color=yellow><b>" + ArenaWorldObjects.UseKeyLabel() + "</b></color>] Configure arena";
		}

		public bool Interact(Humanoid user, bool hold, bool alt)
		{
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			if (hold || (Object)(object)user != (Object)(object)Player.m_localPlayer)
			{
				return false;
			}
			if (!ArenaWorldObjects.IsLocalAdmin())
			{
				((Character)user).Message((MessageType)2, "$arenaguard_admin_only", 0, (Sprite)null);
				return true;
			}
			string text = ResolveCanonicalArenaId();
			if (string.IsNullOrWhiteSpace(text))
			{
				text = ArenaWorldObjects.ArenaAtPositionResolver?.Invoke(((Component)this).transform.position) ?? string.Empty;
			}
			if (string.IsNullOrWhiteSpace(text))
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogWarning((object)"Could not open Arena Core administration because the Core has no arena ID yet.");
				}
				((Character)user).Message((MessageType)2, "This Arena Core is still initializing. Try again in a moment.", 0, (Sprite)null);
				return true;
			}
			ArenaWorldObjects.CoreActivated?.Invoke(text, ArenaWorldObjects.ToPositionData(((Component)this).transform.position));
			ArenaWorldObjects.SelectAdminArena(text);
			ArenaUi.OpenAdminPanel(text, ArenaWorldObjects.ArenaDefinitionResolver?.Invoke(text));
			return true;
		}

		public void ApplyOwnedDisplayName(string displayName)
		{
			WriteOwned("arenaguard.display_name", displayName);
		}

		public void OnRemoved()
		{
			if (ArenaWorldObjects.IsLocalAdmin())
			{
				string text = ResolveCanonicalArenaId();
				if (!string.IsNullOrWhiteSpace(text))
				{
					ArenaWorldObjects.CoreRemovalRequested?.Invoke(text);
				}
			}
		}

		private string ResolveCanonicalArenaId()
		{
			string objectId = base.ObjectId;
			if (!string.IsNullOrWhiteSpace(objectId) && ArenaWorldObjects.ArenaDefinitionResolver?.Invoke(objectId) != null)
			{
				return objectId;
			}
			if (!string.IsNullOrWhiteSpace(base.ArenaId))
			{
				return base.ArenaId;
			}
			return objectId;
		}

		public bool UseItem(Humanoid user, ItemData item)
		{
			return false;
		}
	}
	public sealed class ArenaSignBehaviour : ArenaWorldObjectBehaviour, Hoverable, Interactable
	{
		protected override void Start()
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			base.Start();
			if (base.IsOwner && ArenaWorldObjects.IsLocalAdmin())
			{
				ArenaWorldObjects.ApplyAdminMarker(ArenaWorldObjects.ResolveArenaId(((Component)this).transform.position, base.ArenaId), ArenaMarkerKind.Staging, ((Component)this).transform.position);
			}
		}

		public string GetHoverName()
		{
			return ArenaWorldObjects.Localize("$arenaguard_sign");
		}

		public string GetHoverText()
		{
			return GetHoverName() + "\n[<color=yellow><b>" + ArenaWorldObjects.UseKeyLabel() + "</b></color>] Choose challenge";
		}

		public bool Interact(Humanoid user, bool hold, bool alt)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			if (hold || (Object)(object)user != (Object)(object)Player.m_localPlayer)
			{
				return false;
			}
			string text = ArenaWorldObjects.ResolveArenaId(((Component)this).transform.position, base.ArenaId);
			if (string.IsNullOrWhiteSpace(text))
			{
				((Character)user).Message((MessageType)2, "$arenaguard_unconfigured", 0, (Sprite)null);
				return true;
			}
			ArenaWorldObjects.OpenArenaSign(text);
			return true;
		}

		public bool UseItem(Humanoid user, ItemData item)
		{
			return false;
		}
	}
	public sealed class ArenaChallengeHostBehaviour : ArenaWorldObjectBehaviour, Hoverable, Interactable
	{
		private Character _character;

		public override Vector3 WorldPosition
		{
			get
			{
				//IL_0025: Unknown result type (might be due to invalid IL or missing references)
				//IL_0014: Unknown result type (might be due to invalid IL or missing references)
				if (!((Object)(object)NView != (Object)null))
				{
					return ((Component)this).transform.position;
				}
				return ((Component)NView).transform.position;
			}
		}

		public override float WorldRotationY
		{
			get
			{
				//IL_002a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0014: Unknown result type (might be due to invalid IL or missing references)
				if (!((Object)(object)NView != (Object)null))
				{
					return ((Component)this).transform.eulerAngles.y;
				}
				return ((Component)NView).transform.eulerAngles.y;
			}
		}

		protected override void Awake()
		{
			base.Awake();
			_character = ((Component)this).GetComponent<Character>() ?? ((Component)this).GetComponentInParent<Character>();
			ArenaWorldObjects.TrackChallengeHost(_character);
		}

		private void OnDestroy()
		{
			ArenaWorldObjects.ForgetChallengeHost(_character);
		}

		protected override void Start()
		{
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			base.Start();
			Character character = _character;
			if ((Object)(object)character != (Object)null)
			{
				character.m_name = "$arenaguard_challenge_host";
				character.m_aiSkipTarget = true;
			}
			Humanoid componentInParent = ((Component)this).GetComponentInParent<Humanoid>();
			if (base.IsOwner && (Object)(object)componentInParent != (Object)null)
			{
				componentInParent.EquipBestWeapon((Character)null, (StaticTarget)null, (Character)null, (Character)null);
			}
			if (base.IsOwner && ArenaWorldObjects.IsLocalAdmin())
			{
				ArenaWorldObjects.ApplyAdminMarker(ArenaWorldObjects.ResolveArenaId(WorldPosition, base.ArenaId), ArenaMarkerKind.Staging, WorldPosition);
			}
		}

		public string GetHoverName()
		{
			return ArenaWorldObjects.Localize("$arenaguard_challenge_host");
		}

		public string GetHoverText()
		{
			return GetHoverName() + "\n[<color=yellow><b>" + ArenaWorldObjects.UseKeyLabel() + "</b></color>] Choose challenge";
		}

		public bool Interact(Humanoid user, bool hold, bool alt)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			if (hold || (Object)(object)user != (Object)(object)Player.m_localPlayer)
			{
				return false;
			}
			string text = ArenaWorldObjects.ResolveArenaId(WorldPosition, base.ArenaId);
			if (string.IsNullOrWhiteSpace(text))
			{
				((Character)user).Message((MessageType)2, "$arenaguard_unconfigured", 0, (Sprite)null);
				return true;
			}
			ArenaWorldObjects.OpenArenaSign(text);
			return true;
		}

		public bool UseItem(Humanoid user, ItemData item)
		{
			return false;
		}
	}
	public sealed class ArenaChallengeHostRemoval : MonoBehaviour, IRemoved
	{
		public void OnRemoved()
		{
			if (!ArenaWorldObjects.IsLocalAdmin())
			{
				return;
			}
			ZNetView component = ((Component)this).GetComponent<ZNetView>();
			if ((Object)(object)component != (Object)null && component.IsValid())
			{
				component.ClaimOwnership();
				ZNetScene instance = ZNetScene.instance;
				if (instance != null)
				{
					instance.Destroy(((Component)this).gameObject);
				}
			}
		}
	}
	public sealed class ArenaMarkerBehaviour : ArenaWorldObjectBehaviour, Hoverable, Interactable, IRemoved
	{
		public ArenaMarkerKind MarkerKind;

		private Renderer[] _renderers = Array.Empty<Renderer>();

		private SphereCollider _selectionCollider;

		private readonly MaterialPropertyBlock _appearanceProperties = new MaterialPropertyBlock();

		private bool _appearanceApplied;

		private float _nextVisibilityRefresh;

		public int MarkerSlot => ReadInt("arenaguard.marker_slot", -2);

		protected override void Awake()
		{
			base.Awake();
			_renderers = ((Component)this).GetComponentsInChildren<Renderer>(true);
			_selectionCollider = ((Component)this).GetComponent<SphereCollider>();
			if ((Object)(object)Player.m_localPlayer != (Object)null)
			{
				ApplyAdminVisibility();
			}
		}

		protected override void Start()
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			bool flag = ReadBool("arenaguard.placement_reported", fallback: false);
			base.Start();
			ApplyAdminVisibility();
			if (!base.IsOwner || !ArenaWorldObjects.IsLocalAdmin())
			{
				return;
			}
			string arenaId = ArenaWorldObjects.ResolveArenaId(WorldPosition, base.ArenaId);
			int slot = ((MarkerKind == ArenaMarkerKind.EnemySpawn) ? ResolveEnemySlot(arenaId) : (-1));
			int num = ArenaWorldObjects.ApplyAdminMarker(arenaId, MarkerKind, WorldPosition, slot);
			if (num != -2)
			{
				WriteOwned("arenaguard.marker_kind", (int)MarkerKind);
				WriteOwned("arenaguard.marker_slot", num);
			}
			else if (!flag && (Object)(object)NView != (Object)null && NView.IsValid())
			{
				NView.ClaimOwnership();
				ZNetScene instance = ZNetScene.instance;
				if (instance != null)
				{
					instance.Destroy(((Component)NView).gameObject);
				}
			}
		}

		private void Update()
		{
			if (!(Time.unscaledTime < _nextVisibilityRefresh))
			{
				_nextVisibilityRefresh = Time.unscaledTime + 0.5f;
				ApplyAdminVisibility();
			}
		}

		private int ResolveEnemySlot(string arenaId)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			int markerSlot = MarkerSlot;
			if (markerSlot >= 0 && markerSlot < 4)
			{
				return markerSlot;
			}
			int num = ArenaWorldObjects.ResolveConfiguredEnemySlot(arenaId, WorldPosition);
			if (num >= 0)
			{
				return num;
			}
			HashSet<int> hashSet = new HashSet<int>();
			ArenaMarkerBehaviour[] array = Object.FindObjectsByType<ArenaMarkerBehaviour>((FindObjectsInactive)0, (FindObjectsSortMode)0);
			foreach (ArenaMarkerBehaviour arenaMarkerBehaviour in array)
			{
				if (!((Object)(object)arenaMarkerBehaviour == (Object)null) && arenaMarkerBehaviour != this && arenaMarkerBehaviour.MarkerKind == ArenaMarkerKind.EnemySpawn && string.Equals(ArenaWorldObjects.ResolveArenaId(arenaMarkerBehaviour.WorldPosition, arenaMarkerBehaviour.ArenaId), arenaId, StringComparison.Ordinal))
				{
					int markerSlot2 = arenaMarkerBehaviour.MarkerSlot;
					if (markerSlot2 >= 0 && markerSlot2 < 4)
					{
						hashSet.Add(markerSlot2);
					}
				}
			}
			for (int j = 0; j < 4; j++)
			{
				if (!hashSet.Contains(j))
				{
					return j;
				}
			}
			return -2;
		}

		private void ApplyAdminVisibility()
		{
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_012f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0159: Unknown result type (might be due to invalid IL or missing references)
			//IL_0160: Unknown result type (might be due to invalid IL or missing references)
			bool enabled = ArenaWorldObjects.ShouldShowAdminSetupVisuals();
			Renderer[] renderers = _renderers;
			foreach (Renderer val in renderers)
			{
				if ((Object)(object)val != (Object)null)
				{
					val.enabled = enabled;
				}
			}
			if (!_appearanceApplied)
			{
				Color val2 = ArenaWorldObjects.MarkerColor(MarkerKind);
				renderers = _renderers;
				foreach (Renderer val3 in renderers)
				{
					if (!((Object)(object)val3 == (Object)null))
					{
						Material sharedMaterial = val3.sharedMaterial;
						_appearanceProperties.Clear();
						val3.GetPropertyBlock(_appearanceProperties);
						if ((Object)(object)sharedMaterial != (Object)null && sharedMaterial.HasProperty("_MainTex"))
						{
							_appearanceProperties.SetTexture("_MainTex", (Texture)(object)Texture2D.whiteTexture);
						}
						if ((Object)(object)sharedMaterial != (Object)null && sharedMaterial.HasProperty("_BaseMap"))
						{
							_appearanceProperties.SetTexture("_BaseMap", (Texture)(object)Texture2D.whiteTexture);
						}
						if ((Object)(object)sharedMaterial != (Object)null && sharedMaterial.HasProperty("_Color"))
						{
							_appearanceProperties.SetColor("_Color", val2);
						}
						if ((Object)(object)sharedMaterial != (Object)null && sharedMaterial.HasProperty("_BaseColor"))
						{
							_appearanceProperties.SetColor("_BaseColor", val2);
						}
						if ((Object)(object)sharedMaterial != (Object)null && sharedMaterial.HasProperty("_EmissionColor"))
						{
							_appearanceProperties.SetColor("_EmissionColor", val2 * 1.4f);
						}
						val3.SetPropertyBlock(_appearanceProperties);
					}
				}
				_appearanceApplied = true;
			}
			if ((Object)(object)_selectionCollider != (Object)null)
			{
				((Collider)_selectionCollider).isTrigger = true;
				((Collider)_selectionCollider).enabled = enabled;
			}
		}

		internal void RefreshAdminVisibility()
		{
			ApplyAdminVisibility();
		}

		public string GetHoverName()
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			if (!ArenaWorldObjects.IsLocalAdmin())
			{
				return string.Empty;
			}
			int num = MarkerSlot;
			if (MarkerKind == ArenaMarkerKind.EnemySpawn && (num < 0 || num > 3))
			{
				num = ArenaWorldObjects.ResolveConfiguredEnemySlot(ArenaWorldObjects.ResolveArenaId(WorldPosition, base.ArenaId), WorldPosition);
			}
			if (MarkerKind != ArenaMarkerKind.EnemySpawn || num < 0)
			{
				if (MarkerKind != ArenaMarkerKind.CombatantStart)
				{
					return MarkerKind.ToString() + " Position";
				}
				return "Combat Start";
			}
			return "Enemy Spawn " + (num + 1);
		}

		public string GetHoverText()
		{
			if (!ArenaWorldObjects.IsLocalAdmin())
			{
				return string.Empty;
			}
			return GetHoverName() + "\nRemove with the Arena Admin Hammer";
		}

		public void OnRemoved()
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			if (ArenaWorldObjects.IsLocalAdmin())
			{
				string arenaId = ArenaWorldObjects.ResolveArenaId(WorldPosition, base.ArenaId);
				int num = ((MarkerKind == ArenaMarkerKind.EnemySpawn) ? MarkerSlot : (-1));
				if (MarkerKind == ArenaMarkerKind.EnemySpawn && (num < 0 || num > 3))
				{
					num = ArenaWorldObjects.ResolveConfiguredEnemySlot(arenaId, WorldPosition);
				}
				if (MarkerKind != ArenaMarkerKind.EnemySpawn || (num >= 0 && num < 4))
				{
					ArenaWorldObjects.RemoveAdminMarker(arenaId, MarkerKind, WorldPosition, num);
				}
			}
		}

		public bool Interact(Humanoid user, bool hold, bool alt)
		{
			return false;
		}

		public bool UseItem(Humanoid user, ItemData item)
		{
			return false;
		}
	}
}
namespace ArenaGuard.UI
{
	public enum ArenaUiAdminMutationKind
	{
		SaveDefinition,
		EnableArena,
		DisableArena,
		SetTerrainPermission,
		SetBuildingPermission,
		SetPickupPermission
	}
	public enum ArenaAdminPermissionKind
	{
		Terrain,
		Building,
		DroppedItemPickup
	}
	public sealed class ArenaUiAdminMutation
	{
		public string ArenaId;

		public ArenaUiAdminMutationKind Kind;

		public string DisplayName;

		public float CombatRadius;

		public float ProtectedRadius;

		public bool Enabled;
	}
	public static class ArenaUi
	{
		private sealed class ChallengeMenuState
		{
			internal string ArenaId;

			internal ChallengeMode Mode;

			internal ProgressionCapMode CapMode;

			internal BiomeTier SelectedBiome;

			internal CreatureDefinition SelectedCreature;

			internal StarLevel Stars;

			internal int Quantity;

			internal Button[] ModeButtons;

			internal Button[] CapButtons;

			internal Button BiomeButton;

			internal Button[] StarButtons;

			internal Button ChangeCreatureButton;

			internal Button DecreaseQuantityButton;

			internal Button IncreaseQuantityButton;

			internal Image CreatureIcon;

			internal Image SecondaryCreatureIcon;

			internal Text CreatureSummary;

			internal Text ScopeSummary;

			internal Text StarsLabel;

			internal Text QuantityLabel;

			internal Text QuantityText;

			internal Text EncounterSummary;
		}

		private sealed class FoodPreparationState
		{
			internal string ArenaId;

			internal List<ArenaFoodDefinition> Foods;

			internal List<string> SelectedPrefabNames;

			internal DateTime DeadlineUtc;

			internal float[] ScrollPositions;

			internal ScrollRect[] ScrollRects;

			internal Text DeadlineLabel;
		}

		private static GameObject _modalRoot;

		private static GameObject _creaturePickerRoot;

		private static GameObject _biomePickerRoot;

		private static GameObject _hudRoot;

		private static GameObject _queueRoot;

		private static Text _hudText;

		private static Text _queueText;

		private static Button _forfeitButton;

		private static Button _setupVisibilityButton;

		private static Button _terrainPermissionButton;

		private static Button _buildingPermissionButton;

		private static Button _pickupPermissionButton;

		private static bool _inputBlocked;

		private static GameObject _driverHost;

		private static string _activeArenaId = string.Empty;

		private static string _hudArenaId = string.Empty;

		private static string _queueArenaId = string.Empty;

		private static ArenaClientSnapshot _hudSnapshot;

		private static long _hudElapsedBaseMilliseconds;

		private static float _hudElapsedBaseTime;

		private static float _nextHudTimerRefreshTime;

		private static DateTime _queueDeadlineUtc;

		private static List<CreatureDefinition> _creatures = new List<CreatureDefinition>();

		private static ChallengeMenuState _challengeMenu;

		private static bool _combinedLeaderboardActive;

		private static ProgressionCapMode _leaderboardCapMode;

		private static BiomeTier _leaderboardSelectedBiome;

		private static List<LeaderboardEntry> _biomeLeaderboardEntries;

		private static List<LeaderboardEntry> _starLeaderboardEntries;

		private static List<BiomeTier> _ladderBiomes = new List<BiomeTier>();

		private static FoodPreparationState _foodPreparation;

		private static readonly Dictionary<string, Sprite> CreatureIconCache = new Dictionary<string, Sprite>(StringComparer.Ordinal);

		private static readonly Color SectionColor = new Color(0.96f, 0.64f, 0.22f, 1f);

		private static readonly Color SelectedButtonColor = new Color(1f, 0.56f, 0.12f, 1f);

		private static readonly Color NormalButtonColor = new Color(0.58f, 0.56f, 0.52f, 1f);

		private static readonly Color DisabledTextColor = new Color(0.5f, 0.5f, 0.5f, 1f);

		public static Action<ChallengeRequest> ChallengeRequested;

		public static Action QueueAccepted;

		public static Action ForfeitRequested;

		public static Action<string, LeaderboardKey> LeaderboardRequested;

		public static Action<ArenaUiAdminMutation> AdminMutationRequested;

		public static Func<ArenaAdminPermissionKind, bool> AdminPermissionResolver;

		public static Func<IEnumerable<CreatureDefinition>> CreatureListResolver;

		public static Func<IList<string>, bool> FoodPreparationConfirmed;

		public static Action FoodPreparationCancelled;

		public static void OpenChallengeMenu(string arenaId)
		{
			//IL_01e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_021e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0254: Unknown result type (might be due to invalid IL or missing references)
			//IL_0299: Unknown result type (might be due to invalid IL or missing references)
			//IL_02de: Unknown result type (might be due to invalid IL or missing references)
			//IL_0326: Unknown result type (might be due to invalid IL or missing references)
			//IL_035c: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_03fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_042b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0462: Unknown result type (might be due to invalid IL or missing references)
			//IL_049b: Unknown result type (might be due to invalid IL or missing references)
			//IL_04e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0537: Unknown result type (might be due to invalid IL or missing references)
			//IL_056f: Unknown result type (might be due to invalid IL or missing references)
			//IL_05c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0603: Unknown result type (might be due to invalid IL or missing references)
			//IL_0652: Unknown result type (might be due to invalid IL or missing references)
			//IL_06a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_06fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0732: Unknown result type (might be due to invalid IL or missing references)
			//IL_078a: Unknown result type (might be due to invalid IL or missing references)
			//IL_07c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_081a: Unknown result type (might be due to invalid IL or missing references)
			//IL_084d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0896: Unknown result type (might be due to invalid IL or missing references)
			//IL_08df: Unknown result type (might be due to invalid IL or missing references)
			if (!string.IsNullOrWhiteSpace(arenaId) && CanDraw())
			{
				CloseModal();
				_activeArenaId = arenaId;
				_creatures = (from c in CreatureListResolver?.Invoke() ?? Enumerable.Empty<CreatureDefinition>()
					where c?.Enabled ?? false
					orderby c.Biome, c.IsMiniboss, c.DifficultyOrder
					select c).ThenBy<CreatureDefinition, string>((CreatureDefinition c) => c.DisplayName, StringComparer.OrdinalIgnoreCase).ToList();
				_ladderBiomes = (from biome in _creatures.Select((CreatureDefinition creature) => creature.Biome).Distinct()
					orderby biome
					select biome).ToList();
				_challengeMenu = new ChallengeMenuState
				{
					ArenaId = arenaId,
					Mode = ChallengeMode.BiomeLadder,
					CapMode = ProgressionCapMode.Gauntlet,
					SelectedBiome = ((_ladderBiomes.Count == 0) ? BiomeTier.BlackForest : _ladderBiomes[0]),
					SelectedCreature = _creatures.FirstOrDefault(),
					Stars = StarLevel.Base,
					Quantity = 1
				};
				_modalRoot = CreatePanel("ARENA CHALLENGE", 620f, 690f);
				((Graphic)AddLabel(_modalRoot.transform, "Choose your challenge", 19, new Vector2(0f, 249f), 560f, 32f)).color = SectionColor;
				AddSectionLabel(_modalRoot.transform, "CHOOSE MODE", new Vector2(0f, 215f), 550f);
				_challengeMenu.ModeButtons = (Button[])(object)new Button[3]
				{
					AddModeCard(_modalRoot.transform, "<b>BIOME LADDER</b>\n<size=15>Fight through\nbiome waves</size>", new Vector2(-190f, 151f), delegate
					{
						SetChallengeMode(ChallengeMode.BiomeLadder);
					}),
					AddModeCard(_modalRoot.transform, "<b>STAR LADDER</b>\n<size=15>Base, 1-star,\nthen 2-star</size>", new Vector2(0f, 151f), delegate
					{
						SetChallengeMode(ChallengeMode.StarLadder);
					}),
					AddModeCard(_modalRoot.transform, "<b>SPECIFIC MONSTER</b>\n<size=15>Build a custom\nfight</size>", new Vector2(190f, 151f), delegate
					{
						SetChallengeMode(ChallengeMode.CustomEncounter);
					})
				};
				AddSectionLabel(_modalRoot.transform, "PROGRESSION", new Vector2(0f, 79f), 550f);
				_challengeMenu.CapButtons = (Button[])(object)new Button[2]
				{
					AddButton(_modalRoot.transform, "GAUNTLET — Every biome", new Vector2(-142f, 45f), 260f, 38f, delegate
					{
						SetProgressionCap(ProgressionCapMode.Gauntlet);
					}),
					AddButton(_modalRoot.transform, "BIOME — Choose one", new Vector2(142f, 45f), 260f, 38f, delegate
					{
						SetProgressionCap(ProgressionCapMode.Biome);
					})
				};
				AddSectionLabel(_modalRoot.transform, "ENCOUNTER SETUP", new Vector2(0f, 3f), 550f);
				_challengeMenu.CreatureIcon = AddImage(_modalRoot.transform, "SelectedCreatureIcon", new Vector2(-245f, -47f), 54f, 54f);
				_challengeMenu.SecondaryCreatureIcon = AddImage(_modalRoot.transform, "SelectedSecondaryCreatureIcon", new Vector2(-213f, -47f), 48f, 48f);
				_challengeMenu.CreatureSummary = AddLabel(_modalRoot.transform, string.Empty, 18, new Vector2(-43f, -47f), 350f, 58f);
				_challengeMenu.CreatureSummary.alignment = (TextAnchor)3;
				_challengeMenu.ChangeCreatureButton = AddButton(_modalRoot.transform, "Change", new Vector2(235f, -47f), 112f, 40f, OpenCreaturePicker);
				_challengeMenu.ScopeSummary = AddLabel(_modalRoot.transform, "Every biome • Black Forest → Ashlands", 19, new Vector2(0f, -47f), 500f, 48f, bold: true);
				_challengeMenu.BiomeButton = AddButton(_modalRoot.transform, "Biome: Black Forest", new Vector2(0f, -47f), 320f, 42f, OpenBiomePicker);
				_challengeMenu.StarsLabel = AddLabel(_modalRoot.transform, "STARS", 17, new Vector2(-175f, -91f), 180f, 26f);
				_challengeMenu.StarButtons = (Button[])(object)new Button[3]
				{
					AddButton(_modalRoot.transform, "Base", new Vector2(-220f, -125f), 82f, 38f, delegate
					{
						SetStarLevel(StarLevel.Base);
					}),
					AddButton(_modalRoot.transform, "1 Star", new Vector2(-130f, -125f), 82f, 38f, delegate
					{
						SetStarLevel(StarLevel.OneStar);
					}),
					AddButton(_modalRoot.transform, "2 Stars", new Vector2(-40f, -125f), 82f, 38f, delegate
					{
						SetStarLevel(StarLevel.TwoStar);
					})
				};
				_challengeMenu.QuantityLabel = AddLabel(_modalRoot.transform, "QUANTITY", 17, new Vector2(165f, -91f), 190f, 26f);
				_challengeMenu.DecreaseQuantityButton = AddButton(_modalRoot.transform, "−", new Vector2(105f, -125f), 44f, 38f, delegate
				{
					ChangeQuantity(-1);
				});
				_challengeMenu.QuantityText = AddLabel(_modalRoot.transform, "1", 22, new Vector2(165f, -125f), 62f, 38f, bold: true);
				_challengeMenu.IncreaseQuantityButton = AddButton(_modalRoot.transform, "+", new Vector2(225f, -125f), 44f, 38f, delegate
				{
					ChangeQuantity(1);
				});
				_challengeMenu.EncounterSummary = AddLabel(_modalRoot.transform, string.Empty, 17, new Vector2(0f, -179f), 550f, 42f, bold: true);
				AddButton(_modalRoot.transform, "JOIN QUEUE", new Vector2(0f, -232f), 340f, 50f, SubmitChallenge);
				AddButton(_modalRoot.transform, "Leaderboard", new Vector2(-120f, -291f), 210f, 40f, RequestChallengeLeaderboard);
				AddButton(_modalRoot.transform, "Close", new Vector2(120f, -291f), 210f, 40f, CloseModal);
				RefreshChallengeMenu();
			}
		}

		private static void SetChallengeMode(ChallengeMode mode)
		{
			if (_challengeMenu != null)
			{
				_challengeMenu.Mode = mode;
				if (mode != ChallengeMode.CustomEncounter && (Object)(object)_creaturePickerRoot != (Object)null)
				{
					CloseCreaturePicker();
				}
				RefreshChallengeMenu();
				if (mode == ChallengeMode.CustomEncounter)
				{
					OpenCreaturePicker();
				}
			}
		}

		private static void SetProgressionCap(ProgressionCapMode capMode)
		{
			if (_challengeMenu != null)
			{
				_challengeMenu.CapMode = capMode;
				RefreshChallengeMenu();
				if (capMode == ProgressionCapMode.Biome)
				{
					OpenBiomePicker();
				}
			}
		}

		private static void SetStarLevel(StarLevel stars)
		{
			if (_challengeMenu?.SelectedCreature != null && _challengeMenu.SelectedCreature.SupportedStars != null && _challengeMenu.SelectedCreature.SupportedStars.Contains(stars))
			{
				_challengeMenu.Stars = stars;
				RefreshChallengeMenu();
			}
		}

		private static void ChangeQuantity(int amount)
		{
			if (_challengeMenu != null)
			{
				_challengeMenu.Quantity = Mathf.Clamp(_challengeMenu.Quantity + amount, 1, 10);
				RefreshChallengeMenu();
			}
		}

		private static void RefreshChallengeMenu()
		{
			//IL_0226: Unknown result type (might be due to invalid IL or missing references)
			ChallengeMenuState challengeMenu = _challengeMenu;
			if (challengeMenu != null && !((Object)(object)_modalRoot == (Object)null))
			{
				for (int i = 0; i < challengeMenu.ModeButtons.Length; i++)
				{
					SetButtonSelected(challengeMenu.ModeButtons[i], challengeMenu.Mode == (ChallengeMode)(i + 1));
				}
				SetButtonSelected(challengeMenu.CapButtons[0], challengeMenu.CapMode == ProgressionCapMode.Gauntlet);
				SetButtonSelected(challengeMenu.CapButtons[1], challengeMenu.CapMode == ProgressionCapMode.Biome);
				bool flag = challengeMenu.Mode == ChallengeMode.CustomEncounter;
				bool flag2 = !flag;
				bool flag3 = challengeMenu.SelectedCreature != null;
				Button[] capButtons = challengeMenu.CapButtons;
				for (int j = 0; j < capButtons.Length; j++)
				{
					((Selectable)capButtons[j]).interactable = flag2;
				}
				bool flag4 = flag2 && challengeMenu.CapMode == ProgressionCapMode.Biome;
				if (!flag4 && (Object)(object)_biomePickerRoot != (Object)null)
				{
					CloseBiomePicker();
				}
				((Component)challengeMenu.BiomeButton).gameObject.SetActive(flag4);
				((Component)challengeMenu.ScopeSummary).gameObject.SetActive(flag2 && !flag4);
				if (flag4 && _ladderBiomes.Count > 0)
				{
					int index = Math.Max(0, _ladderBiomes.IndexOf(challengeMenu.SelectedBiome));
					challengeMenu.SelectedBiome = _ladderBiomes[index];
					UpdateButtonLabel(challengeMenu.BiomeButton, "Biome: " + BiomeLabel(challengeMenu.SelectedBiome) + "  ›");
				}
				if (flag2 && !flag4)
				{
					challengeMenu.ScopeSummary.text = "Every biome • " + ((_ladderBiomes.Count == 0) ? "Roster unavailable" : (BiomeLabel(_ladderBiomes.First()) + " → " + BiomeLabel(_ladderBiomes.Last())));
				}
				((Component)challengeMenu.CreatureIcon).gameObject.SetActive(flag);
				((Component)challengeMenu.SecondaryCreatureIcon).gameObject.SetActive(flag);
				((Component)challengeMenu.CreatureSummary).gameObject.SetActive(flag);
				((Component)challengeMenu.ChangeCreatureButton).gameObject.SetActive(flag);
				((Selectable)challengeMenu.ChangeCreatureButton).interactable = flag && _creatures.Count != 0;
				((Graphic)challengeMenu.CreatureSummary).color = Color.white;
				((Component)challengeMenu.StarsLabel).gameObject.SetActive(flag);
				((Component)challengeMenu.QuantityLabel).gameObject.SetActive(flag);
				((Selectable)challengeMenu.DecreaseQuantityButton).interactable = flag && challengeMenu.Quantity > 1;
				((Selectable)challengeMenu.IncreaseQuantityButton).interactable = flag && challengeMenu.Quantity < 10;
				((Component)challengeMenu.QuantityText).gameObject.SetActive(flag);
				((Component)challengeMenu.DecreaseQuantityButton).gameObject.SetActive(flag);
				((Component)challengeMenu.IncreaseQuantityButton).gameObject.SetActive(flag);
				for (int k = 0; k < challengeMenu.StarButtons.Length; k++)
				{
					StarLevel starLevel = (StarLevel)k;
					bool flag5 = flag3 && challengeMenu.SelectedCreature.SupportedStars != null && challengeMenu.SelectedCreature.SupportedStars.Contains(starLevel);
					((Component)challengeMenu.StarButtons[k]).gameObject.SetActive(flag);
					((Selectable)challengeMenu.StarButtons[k]).interactable = flag && flag5;
					SetButtonSelected(challengeMenu.StarButtons[k], flag && challengeMenu.Stars == starLevel);
				}
				challengeMenu.CreatureSummary.text = (flag3 ? (challengeMenu.SelectedCreature.DisplayName + "\n<color=#9FD66B>" + BiomeLabel(challengeMenu.SelectedCreature.Biome) + (challengeMenu.SelectedCreature.IsMiniboss ? " • Miniboss" : string.Empty) + "</color>") : "Roster unavailable");
				SetCreatureIcons(challengeMenu.CreatureIcon, challengeMenu.SecondaryCreatureIcon, challengeMenu.SelectedCreature);
				challengeMenu.QuantityText.text = challengeMenu.Quantity.ToString(CultureInfo.InvariantCulture);
				switch (challengeMenu.Mode)
				{
				case ChallengeMode.BiomeLadder:
					challengeMenu.EncounterSummary.text = ((challengeMenu.CapMode == ProgressionCapMode.Gauntlet) ? "GAUNTLET: EVERY BIOME • WEAKEST TO STRONGEST" : ("BIOME: " + BiomeLabel(challengeMenu.SelectedBiome).ToUpperInvariant() + " • EVERY MOB • WEAKEST TO STRONGEST"));
					return;
				case ChallengeMode.StarLadder:
					challengeMenu.EncounterSummary.text = ((challengeMenu.CapMode == ProgressionCapMode.Gauntlet) ? "GAUNTLET: EVERY BIOME" : ("BIOME: " + BiomeLabel(challengeMenu.SelectedBiome).ToUpperInvariant())) + " • BASE → 1 STAR → 2 STARS";
					return;
				}
				challengeMenu.EncounterSummary.text = (flag3 ? ("ENCOUNTER: " + challengeMenu.Quantity + " × " + StarLabel(challengeMenu.Stars).ToUpperInvariant() + " " + challengeMenu.SelectedCreature.DisplayName.ToUpperInvariant()) : "ENCOUNTER: SELECT A CREATURE");
			}
		}

		private static void SubmitChallenge()
		{
			ChallengeMenuState challengeMenu = _challengeMenu;
			if (challengeMenu == null)
			{
				return;
			}
			if (challengeMenu.Mode == ChallengeMode.CustomEncounter && challengeMenu.SelectedCreature == null)
			{
				ShowMessage("Choose a creature for the selected encounter.");
				return;
			}
			if (ChallengeRequested == null)
			{
				ShowMessage("Arena networking is not ready yet.");
				return;
			}
			ChallengeRequest challengeRequest = new ChallengeRequest
			{
				RequestId = Guid.NewGuid().ToString("N").ToLowerInvariant(),
				ArenaId = challengeMenu.ArenaId,
				PlayerId = 0L,
				PlayerName = string.Empty,
				Mode = challengeMenu.Mode,
				CapMode = challengeMenu.CapMode,
				SelectedBiome = challengeMenu.SelectedBiome,
				RequestedUtc = DateTime.UtcNow
			};
			if (challengeMenu.Mode == ChallengeMode.CustomEncounter)
			{
				challengeRequest.CustomSelection = new CustomEncounterSelection
				{
					CreatureKey = challengeMenu.SelectedCreature.CreatureKey,
					Stars = challengeMenu.Stars,
					Quantity = challengeMenu.Quantity
				};
			}
			ChallengeRequested(challengeRequest);
			CloseModal();
		}

		private static void RequestChallengeLeaderboard()
		{
			ChallengeMenuState challengeMenu = _challengeMenu;
			if (challengeMenu != null)
			{
				if (LeaderboardRequested == null)
				{
					ShowMessage("Arena leaderboard networking is not ready yet.");
					return;
				}
				string arenaId = challengeMenu.ArenaId;
				_combinedLeaderboardActive = true;
				_leaderboardCapMode = challengeMenu.CapMode;
				_leaderboardSelectedBiome = challengeMenu.SelectedBiome;
				_biomeLeaderboardEntries = null;
				_starLeaderboardEntries = null;
				RenderCombinedLeaderboard();
				LeaderboardRequested(arenaId, new LeaderboardKey
				{
					Mode = ChallengeMode.BiomeLadder,
					CapMode = _leaderboardCapMode,
					SelectedBiome = _leaderboardSelectedBiome
				});
				LeaderboardRequested(arenaId, new LeaderboardKey
				{
					Mode = ChallengeMode.StarLadder,
					CapMode = _leaderboardCapMode,
					SelectedBiome = _leaderboardSelectedBiome
				});
			}
		}

		private static void OpenBiomePicker()
		{
			ChallengeMenuState challengeMenu = _challengeMenu;
			if (challengeMenu != null && challengeMenu.Mode != ChallengeMode.CustomEncounter && challengeMenu.CapMode == ProgressionCapMode.Biome)
			{
				List<BiomeTier> list = SelectableLadderBiomes();
				if (list.Count == 0)
				{
					ShowMessage("No arena biomes are currently available.");
				}
				else
				{
					BuildBiomePicker(list.Contains(challengeMenu.SelectedBiome) ? challengeMenu.SelectedBiome : list[0]);
				}
			}
		}

		private static void BuildBiomePicker(BiomeTier pendingSelection)
		{
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0135: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0229: Unknown result type (might be due to invalid IL or missing references)
			ChallengeMenuState challengeMenu = _challengeMenu;
			List<BiomeTier> list = SelectableLadderBiomes();
			if (challengeMenu == null || list.Count == 0 || (Object)(object)_modalRoot == (Object)null)
			{
				return;
			}
			bool flag = (Object)(object)_biomePickerRoot != (Object)null;
			Vector2 panelPosition = GetPanelPosition(_modalRoot);
			Vector2 position = (Vector2)(flag ? GetPanelPosition(_biomePickerRoot) : new Vector2(335f, 0f));
			Destroy(ref _biomePickerRoot);
			SetPanelPosition(_modalRoot, (Vector2)(flag ? panelPosition : new Vector2(-315f, 0f)));
			_biomePickerRoot = CreatePanel("SELECT BIOME", 390f, 570f, preserveExistingInputBlock: true);
			SetPanelPosition(_biomePickerRoot, position);
			((Graphic)AddLabel(_biomePickerRoot.transform, "Choose one biome for this ladder.", 18, new Vector2(0f, 205f), 330f, 36f)).color = SectionColor;
			for (int i = 0; i < list.Count; i++)
			{
				BiomeTier candidate = list[i];
				SetButtonSelected(AddButton(_biomePickerRoot.transform, BiomeLabel(candidate), new Vector2(0f, 150f - (float)i * 55f), 300f, 42f, delegate
				{
					BuildBiomePicker(candidate);
				}), candidate == pendingSelection);
			}
			((Graphic)AddLabel(_biomePickerRoot.transform, "Selected: " + BiomeLabel(pendingSelection), 18, new Vector2(0f, -188f), 330f, 34f)).color = SectionColor;
			AddButton(_biomePickerRoot.transform, "CANCEL", new Vector2(-90f, -240f), 150f, 42f, CloseBiomePicker);
			AddButton(_biomePickerRoot.transform, "SELECT", new Vector2(90f, -240f), 150f, 42f, delegate
			{
				if (_challengeMenu != null)
				{
					_challengeMenu.SelectedBiome = pendingSelection;
					CloseBiomePicker();
					RefreshChallengeMenu();
				}
			});
			_biomePickerRoot.transform.SetAsLastSibling();
		}

		private static List<BiomeTier> SelectableLadderBiomes()
		{
			return (from biome in _ladderBiomes.Where((BiomeTier biome) => biome >= BiomeTier.BlackForest && biome <= BiomeTier.Ashlands).Distinct()
				orderby biome
				select biome).ToList();
		}

		private static void CloseBiomePicker()
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			Destroy(ref _biomePickerRoot);
			if ((Object)(object)_modalRoot != (Object)null)
			{
				SetPanelPosition(_modalRoot, Vector2.zero);
				_modalRoot.transform.SetAsLastSibling();
			}
			RefreshInputBlock();
		}

		private static void OpenCreaturePicker()
		{
			ChallengeMenuState challengeMenu = _challengeMenu;
			if (challengeMenu != null && challengeMenu.Mode == ChallengeMode.CustomEncounter && _creatures.Count != 0)
			{
				BuildCreaturePicker(challengeMenu.SelectedCreature?.Biome ?? _creatures[0].Biome, challengeMenu.SelectedCreature);
			}
		}

		private static void BuildCreaturePicker(BiomeTier biome, CreatureDefinition pendingSelection)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0180: Unknown result type (might be due to invalid IL or missing references)
			//IL_026d: Unknown result type (might be due to invalid IL or missing references)
			//IL_031c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0331: Unknown result type (might be due to invalid IL or missing references)
			//IL_0354: Unknown result type (might be due to invalid IL or missing references)
			//IL_039b: Unknown result type (might be due to invalid IL or missing references)
			bool flag = (Object)(object)_creaturePickerRoot != (Object)null;
			Vector2 panelPosition = GetPanelPosition(_modalRoot);
			Vector2 position = (Vector2)(flag ? GetPanelPosition(_creaturePickerRoot) : new Vector2(325f, 0f));
			Destroy(ref _creaturePickerRoot);
			if ((Object)(object)_modalRoot == (Object)null)
			{
				return;
			}
			SetPanelPosition(_modalRoot, (Vector2)(flag ? panelPosition : new Vector2(-340f, 0f)));
			_creaturePickerRoot = CreatePanel("SELECT CREATURE", 680f, 630f, preserveExistingInputBlock: true);
			SetPanelPosition(_creaturePickerRoot, position);
			List<BiomeTier> list = (from value in _creatures.Select((CreatureDefinition creature) => creature.Biome).Distinct()
				orderby value
				select value).ToList();
			float num = Math.Min(100f, 620f / (float)Math.Max(1, list.Count));
			float num2 = (float)(-(list.Count - 1)) * num / 2f;
			for (int num3 = 0; num3 < list.Count; num3++)
			{
				BiomeTier tabBiome = list[num3];
				Button obj = AddButton(_creaturePickerRoot.transform, BiomeLabel(tabBiome), new Vector2(num2 + (float)num3 * num, 220f), num - 4f, 36f, delegate
				{
					BuildCreaturePicker(tabBiome, pendingSelection);
				});
				SetButtonSelected(obj, tabBiome == biome);
				Text componentInChildren = ((Component)obj).GetComponentInChildren<Text>(true);
				if ((Object)(object)componentInChildren != (Object)null)
				{
					componentInChildren.fontSize = 14;
				}
			}
			List<CreatureDefinition> list2 = _creatures.Where((CreatureDefinition creature) => creature.Biome == biome).ToList();
			for (int num4 = 0; num4 < list2.Count && num4 < 12; num4++)
			{
				CreatureDefinition candidate = list2[num4];
				int num5 = num4 % 4;
				int num6 = num4 / 4;
				SetButtonSelected(AddCreatureCard(_creaturePickerRoot.transform, candidate, new Vector2(-246f + (float)num5 * 164f, 133f - (float)num6 * 125f), 148f, 112f, delegate
				{
					BuildCreaturePicker(biome, candidate);
				}), pendingSelection != null && string.Equals(pendingSelection.CreatureKey, candidate.CreatureKey, StringComparison.OrdinalIgnoreCase));
			}
			((Graphic)AddLabel(_creaturePickerRoot.transform, "Selected: " + (pendingSelection?.DisplayName ?? "None"), 19, new Vector2(-80f, -226f), 430f, 38f)).color = SectionColor;
			((Selectable)AddButton(_creaturePickerRoot.transform, "SELECT", new Vector2(175f, -267f), 210f, 44f, delegate
			{
				if (pendingSelection != null && _challengeMenu != null)
				{
					_challengeMenu.SelectedCreature = pendingSelection;
					if (_challengeMenu.SelectedCreature.SupportedStars == null || !_challengeMenu.SelectedCreature.SupportedStars.Contains(_challengeMenu.Stars))
					{
						_challengeMenu.Stars = StarLevel.Base;
					}
					CloseCreaturePicker();
					RefreshChallengeMenu();
				}
			})).interactable = pendingSelection != null;
			AddButton(_creaturePickerRoot.transform, "CANCEL", new Vector2(-65f, -267f), 210f, 44f, CloseCreaturePicker);
			_creaturePickerRoot.transform.SetAsLastSibling();
		}

		private static void CloseCreaturePicker()
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			Destroy(ref _creaturePickerRoot);
			if ((Object)(object)_modalRoot != (Object)null)
			{
				SetPanelPosition(_modalRoot, Vector2.zero);
				_modalRoot.transform.SetAsLastSibling();
			}
			RefreshInputBlock();
		}

		public static void OpenAdminPanel(string arenaId)
		{
			OpenAdminPanel(arenaId, null);
		}

		public static void OpenAdminPanel(string arenaId, ArenaDefinition definition)
		{
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0126: Unknown result type (might be due to invalid IL or missing references)
			//IL_0173: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_022a: Unknown result type (might be due to invalid IL or missing references)
			//IL_025b: Unknown result type (might be due to invalid IL or missing references)
			//IL_028a: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_033a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0369: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0435: Unknown result type (might be due to invalid IL or missing references)
			//IL_0475: Unknown result type (might be due to invalid IL or missing references)
			//IL_04a4: Unknown result type (might be due to invalid IL or missing references)
			if (string.IsNullOrWhiteSpace(arenaId))
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogWarning((object)"Ignored an Arena Core panel request without an arena ID.");
				}
				ShowMessage("This Arena Core is still initializing. Try again in a moment.");
				return;
			}
			if (!CanDraw())
			{
				ManualLogSource log2 = Plugin.Log;
				if (log2 != null)
				{
					log2.LogWarning((object)"Could not open Arena Core administration because the client GUI is not ready.");
				}
				ShowMessage("The Arena administration screen is not ready. Try again in a moment.");
				return;
			}
			CloseModal();
			ArenaWorldObjects.SelectAdminArena(arenaId);
			_activeArenaId = arenaId;
			_modalRoot = CreatePanel("Arena Administration", 820f, 680f);
			AddLabel(_modalRoot.transform, "Name", 20, new Vector2(-285f, 230f), 100f, 35f);
			InputField name = AddInput(_modalRoot.transform, definition?.DisplayName ?? "Arena", new Vector2(75f, 230f), 560f, 42f, (ContentType)0);
			AddLabel(_modalRoot.transform, "Combat radius (blue)", 20, new Vector2(-250f, 170f), 210f, 35f);
			InputField combat = AddInput(_modalRoot.transform, (definition?.CombatRadius ?? 20f).ToString("0.##", CultureInfo.InvariantCulture), new Vector2(-80f, 170f), 120f, 42f, (ContentType)3);
			AddLabel(_modalRoot.transform, "Protected radius (gold)", 20, new Vector2(100f, 170f), 220f, 35f);
			InputField protectedRadius = AddInput(_modalRoot.transform, (definition?.ProtectedRadius ?? 30f).ToString("0.##", CultureInfo.InvariantCulture), new Vector2(275f, 170f), 120f, 42f, (ContentType)3);
			AddLabel(_modalRoot.transform, "Close this panel, then place all position markers with the Arena Admin Hammer:\nRequired: Arena Master = staging  •  1 Combat Start inside blue ring  •  4 Enemy Spawns", 18, new Vector2(0f, 90f), 750f, 75f);
			AddLabel(_modalRoot.transform, "New markers, signs, and gates will target this selected arena.", 17, new Vector2(0f, 28f), 720f, 35f);
			AddButton(_modalRoot.transform, "Save", new Vector2(-220f, -42f), 190f, 50f, delegate
			{
				if (string.IsNullOrWhiteSpace(name.text) || !float.TryParse(combat.text, NumberStyles.Float, CultureInfo.InvariantCulture, out var result) || !float.TryParse(protectedRadius.text, NumberStyles.Float, CultureInfo.InvariantCulture, out var result2) || result <= 0f || result2 <= result)
				{
					ShowMessage("Enter a name and radii where protected is larger than combat.");
				}
				else
				{
					AdminMutationRequested?.Invoke(new ArenaUiAdminMutation
					{
						ArenaId = arenaId,
						Kind = ArenaUiAdminMutationKind.SaveDefinition,
						DisplayName = name.text.Trim(),
						CombatRadius = result,
						ProtectedRadius = result2
					});
				}
			});
			AddButton(_modalRoot.transform, "Enable", new Vector2(0f, -42f), 190f, 50f, delegate
			{
				AdminMutationRequested?.Invoke(new ArenaUiAdminMutation
				{
					ArenaId = arenaId,
					Kind = ArenaUiAdminMutationKind.EnableArena
				});
			});
			AddButton(_modalRoot.transform, "Disable", new Vector2(220f, -42f), 190f, 50f, delegate
			{
				AdminMutationRequested?.Invoke(new ArenaUiAdminMutation
				{
					ArenaId = arenaId,
					Kind = ArenaUiAdminMutationKind.DisableArena
				});
			});
			AddLabel(_modalRoot.transform, "ADMIN PERMISSIONS", 18, new Vector2(0f, -100f), 320f, 30f);
			_setupVisibilityButton = AddButton(_modalRoot.transform, SetupVisibilityButtonText(), new Vector2(-205f, -145f), 350f, 42f, ArenaWorldObjects.ToggleAdminSetupVisuals);
			_terrainPermissionButton = AddButton(_modalRoot.transform, PermissionButtonText(ArenaAdminPermissionKind.Terrain), new Vector2(205f, -145f), 350f, 42f, delegate
			{
				ToggleAdminPermission(arenaId, ArenaAdminPermissionKind.Terrain);
			});
			_buildingPermissionButton = AddButton(_modalRoot.transform, PermissionButtonText(ArenaAdminPermissionKind.Building), new Vector2(-205f, -200f), 350f, 42f, delegate
			{
				ToggleAdminPermission(arenaId, ArenaAdminPermissionKind.Building);
			});
			_pickupPermissionButton = AddButton(_modalRoot.transform, PermissionButtonText(ArenaAdminPermissionKind.DroppedItemPickup), new Vector2(205f, -200f), 350f, 42f, delegate
			{
				ToggleAdminPermission(arenaId, ArenaAdminPermissionKind.DroppedItemPickup);
			});
			AddLabel(_modalRoot.transform, "Terrain also requires devcommands. Permissions never apply to the active combatant.", 16, new Vector2(0f, -245f), 720f, 28f);
			AddButton(_modalRoot.transform, "Close", new Vector2(0f, -292f), 220f, 45f, CloseModal);
			_modalRoot.transform.SetAsLastSibling();
			ManualLogSource log3 = Plugin.Log;
			if (log3 != null)
			{
				log3.LogInfo((object)("Opened Arena Core administration for '" + arenaId + "'."));
			}
		}

		public static void OpenGateAdminPanel(string objectId, string arenaId, string displayName, bool isHubGate, bool isFallback)
		{
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_011e: Unknown result type (might be due to invalid IL or missing references)
			//IL_01df: Unknown result type (might be due to invalid IL or missing references)
			//IL_0219: Unknown result type (might be due to invalid IL or missing references)
			//IL_0161: Unknown result type (might be due to invalid IL or missing references)
			//IL_018c: Unknown result type (might be due to invalid IL or missing references)
			if (string.IsNullOrWhiteSpace(objectId) || !ArenaWorldObjects.IsLocalAdmin() || !CanDraw())
			{
				return;
			}
			CloseModal();
			_modalRoot = CreatePanel(isHubGate ? "Return Gate" : "Arena Gate", 620f, 390f);
			AddLabel(_modalRoot.transform, "Unique name", 20, new Vector2(-195f, 90f), 140f, 35f);
			InputField name = AddInput(_modalRoot.transform, (!string.IsNullOrWhiteSpace(displayName)) ? displayName : (isHubGate ? "Arena Return" : "Arena Gate"), new Vector2(80f, 90f), 350f, 42f, (ContentType)0);
			AddLabel(_modalRoot.transform, string.IsNullOrWhiteSpace(arenaId) ? "Target arena: not selected" : ("Target arena ID: " + arenaId), 17, new Vector2(0f, 28f), 550f, 40f);
			Dropdown fallback = null;
			if (!isHubGate)
			{
				AddLabel(_modalRoot.transform, "Fallback entrance", 20, new Vector2(-180f, -32f), 180f, 35f);
				fallback = AddDropdown(_modalRoot.transform, new Vector2(105f, -32f), 280f, "No", "Yes");
				fallback.value = (isFallback ? 1 : 0);
			}
			AddButton(_modalRoot.transform, "Save", new Vector2(-105f, -115f), 170f, 48f, delegate
			{
				string text = (name.text ?? string.Empty).Trim();
				if (text.Length == 0 || text.Length > 48 || string.IsNullOrWhiteSpace(arenaId))
				{
					ShowMessage("Select an arena and enter a gate name from 1-48 characters.");
				}
				else
				{
					ArenaTeleporters.GateConfigurationRequested?.Invoke(objectId, arenaId, text, !isHubGate && (Object)(object)fallback != (Object)null && fallback.value == 1);
					CloseModal();
				}
			});
			AddButton(_modalRoot.transform, "Close", new Vector2(105f, -115f), 170f, 48f, CloseModal);
		}

		public static bool ShowQueueCall(string arenaId, string sessionId, int seconds = 30)
		{
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			if (string.IsNullOrWhiteSpace(arenaId) || string.IsNullOrWhiteSpace(sessionId) || !CanDraw())
			{
				return false;
			}
			Destroy(ref _queueRoot);
			_activeArenaId = arenaId ?? string.Empty;
			_queueArenaId = arenaId;
			_queueDeadlineUtc = DateTime.UtcNow.AddSeconds(Math.Max(1, seconds));
			_queueRoot = CreatePanel("Your arena is ready", 520f, 260f, preserveExistingInputBlock: true);
			_queueText = AddLabel(_queueRoot.transform, string.Empty, 23, new Vector2(0f, 35f), 460f, 80f);
			AddButton(_queueRoot.transform, "Accept", new Vector2(-115f, -65f), 180f, 48f, delegate
			{
				QueueAccepted?.Invoke();
				CloseQueuePrompt();
			});
			AddButton(_queueRoot.transform, "Not now", new Vector2(115f, -65f), 180f, 48f, CloseQueuePrompt);
			UpdateQueuePrompt();
			return (Object)(object)_queueRoot != (Object)null;
		}

		public static bool OpenFoodPreparation(string arenaId, IEnumerable<ArenaFoodDefinition> foods, IEnumerable<string> preferredPrefabNames, int seconds)
		{
			if (string.IsNullOrWhiteSpace(arenaId) || !CanDraw())
			{
				return false;
			}
			List<ArenaFoodDefinition> list = (from @group in (foods ?? Enumerable.Empty<ArenaFoodDefinition>()).Where((ArenaFoodDefinition food) => food != null && !string.IsNullOrWhiteSpace(food.PrefabName)).GroupBy<ArenaFoodDefinition, string>((ArenaFoodDefinition food) => food.PrefabName, StringComparer.Ordinal)
				select @group.First()).OrderBy<ArenaFoodDefinition, string>((ArenaFoodDefinition food) => food.DisplayName, StringComparer.OrdinalIgnoreCase).ToList();
			HashSet<string> hashSet = new HashSet<string>(list.Select((ArenaFoodDefinition food) => food.PrefabName), StringComparer.Ordinal);
			List<string> list2 = new List<string>();
			foreach (string item in preferredPrefabNames ?? Enumerable.Empty<string>())
			{
				string text = item?.Trim();
				if (text != null && hashSet.Contains(text) && !list2.Contains(text))
				{
					list2.Add(text);
					if (list2.Count == 3)
					{
						break;
					}
				}
			}
			CloseModal();
			_activeArenaId = arenaId;
			FoodPreparationState foodPreparationState = new FoodPreparationState();
			foodPreparationState.ArenaId = arenaId;
			foodPreparationState.Foods = list;
			foodPreparationState.SelectedPrefabNames = list2;
			foodPreparationState.DeadlineUtc = DateTime.UtcNow.AddSeconds(Math.Max(1, seconds));
			foodPreparationState.ScrollPositions = new float[3] { 1f, 1f, 1f };
			_foodPreparation = foodPreparationState;
			BuildFoodPreparation();
			return (Object)(object)_modalRoot != (Object)null;
		}

		public static void CloseFoodPreparation(string arenaId)
		{
			if (_foodPreparation != null && string.Equals(_foodPreparation.ArenaId, arenaId, StringComparison.Ordinal))
			{
				CloseModal();
			}
		}

		private static void BuildFoodPreparation()
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0134: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01de: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_030f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0353: Unknown result type (might be due to invalid IL or missing references)
			//IL_0419: Unknown result type (might be due to invalid IL or missing references)
			FoodPreparationState state = _foodPreparation;
			if (state == null || !CanDraw())
			{
				return;
			}
			bool num = (Object)(object)_modalRoot != (Object)null;
			Vector2 panelPosition = GetPanelPosition(_modalRoot);
			CaptureFoodScrollPositions(state);
			Destroy(ref _modalRoot);
			_modalRoot = CreatePanel("CHOOSE ARENA FOOD", 980f, 720f, preserveExistingInputBlock: true);
			if (num)
			{
				SetPanelPosition(_modalRoot, panelPosition);
			}
			int num2 = Math.Max(0, (int)Math.Ceiling((state.DeadlineUtc - DateTime.UtcNow).TotalSeconds));
			state.DeadlineLabel = AddLabel(_modalRoot.transform, "Choose exactly three foods your character has discovered.  Ready in " + num2 + "s", 18, new Vector2(0f, 265f), 900f, 32f);
			((Graphic)state.DeadlineLabel).color = SectionColor;
			AddLabel(_modalRoot.transform, (state.Foods.Count < 3) ? "Discover at least three foods before entering the arena." : "Arena food is temporary. Pick any three total across Health, Stamina, and Eitr.", 16, new Vector2(0f, 226f), 900f, 42f, bold: true);
			string value = ((state.SelectedPrefabNames.Count == 0) ? "Selected 0/3: none" : ("Selected " + state.SelectedPrefabNames.Count + "/3: " + string.Join("  •  ", state.SelectedPrefabNames.Select((string name, int index) => index + 1 + ". " + state.Foods.First((ArenaFoodDefinition food) => food.PrefabName == name).DisplayName))));
			((Graphic)AddLabel(_modalRoot.transform, value, 16, new Vector2(0f, 185f), 900f, 36f)).color = SectionColor;
			ArenaFoodTab[] array = new ArenaFoodTab[3]
			{
				ArenaFoodTab.Health,
				ArenaFoodTab.Stamina,
				ArenaFoodTab.Eitr
			};
			state.ScrollRects = (ScrollRect[])(object)new ScrollRect[array.Length];
			for (int num3 = 0; num3 < array.Length; num3++)
			{
				ArenaFoodTab tab = array[num3];
				List<ArenaFoodDefinition> list = (from food in state.Foods
					where FoodTab(food) == tab
					orderby ArenaFoodIndexPolicy.Strength(tab, food.Health, food.Stamina, food.Eitr) descending, food.Health + food.Stamina + food.Eitr descending
					select food).ThenBy<ArenaFoodDefinition, string>((ArenaFoodDefinition food) => food.DisplayName, StringComparer.OrdinalIgnoreCase).ToList();
				((Graphic)AddLabel(_modalRoot.transform, FoodTabLabel(tab).ToUpperInvariant() + " (" + list.Count + ")", 17, new Vector2(-310f + (float)num3 * 310f, 145f), 292f, 32f, bold: true)).color = SectionColor;
				state.ScrollRects[num3] = CreateFoodList(_modalRoot.transform, state, tab, list, new Vector2(-310f + (float)num3 * 310f, -45f), 292f, 350f, state.ScrollPositions[num3]);
			}
			((Selectable)AddButton(_modalRoot.transform, "READY", new Vector2(-115f, -307f), 200f, 46f, ConfirmFoodPreparation)).interactable = state.SelectedPrefabNames.Count == 3 && state.Foods.Count >= 3;
			AddButton(_modalRoot.transform, "CANCEL", new Vector2(115f, -307f), 200f, 46f, CancelFoodPreparation);
			_modalRoot.transform.SetAsLastSibling();
		}

		private static ScrollRect CreateFoodList(Transform parent, FoodPreparationState state, ArenaFoodTab tab, IList<ArenaFoodDefinition> foods, Vector2 position, float width, float height, float normalizedPosition)
		{
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Expected O, but got Unknown
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_011d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0132: Unknown result type (might be due to invalid IL or missing references)
			//IL_0147: Unknown result type (might be due to invalid IL or missing references)
			//IL_0169: Unknown result type (might be due to invalid IL or missing references)
			//IL_016e: Unknown result type (might be due to invalid IL or missing references)
			//IL_018c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_0230: Unknown result type (might be due to invalid IL or missing references)
			//IL_0248: Unknown result type (might be due to invalid IL or missing references)
			//IL_04f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0500: Expected O, but got Unknown
			//IL_0525: Unknown result type (might be due to invalid IL or missing references)
			//IL_053a: Unknown result type (might be due to invalid IL or missing references)
			//IL_054f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0564: Unknown result type (might be due to invalid IL or missing references)
			//IL_0578: Unknown result type (might be due to invalid IL or missing references)
			//IL_059d: Unknown result type (might be due to invalid IL or missing references)
			//IL_05cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_05d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_05e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_05ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_05fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0606: Unknown result type (might be due to invalid IL or missing references)
			//IL_0612: Unknown result type (might be due to invalid IL or missing references)
			//IL_0625: Unknown result type (might be due to invalid IL or missing references)
			//IL_0349: Unknown result type (might be due to invalid IL or missing references)
			//IL_037e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0393: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0476: Unknown result type (might be due to invalid IL or missing references)
			//IL_0481: Unknown result type (might be due to invalid IL or missing references)
			//IL_0496: Unknown result type (might be due to invalid IL or missing references)
			//IL_04aa: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject(FoodTabLabel(tab) + "FoodList", new Type[3]
			{
				typeof(RectTransform),
				typeof(Image),
				typeof(ScrollRect)
			});
			val.transform.SetParent(parent, false);
			RectTransform component = val.GetComponent<RectTransform>();
			component.anchorMin = new Vector2(0.5f, 0.5f);
			component.anchorMax = new Vector2(0.5f, 0.5f);
			component.pivot = new Vector2(0.5f, 0.5f);
			component.anchoredPosition = position;
			component.sizeDelta = new Vector2(width, height);
			((Graphic)val.GetComponent<Image>()).color = new Color(0.035f, 0.03f, 0.025f, 0.72f);
			GameObject val2 = new GameObject("Viewport", new Type[2]
			{
				typeof(RectTransform),
				typeof(RectMask2D)
			});
			val2.transform.SetParent(val.transform, false);
			RectTransform component2 = val2.GetComponent<RectTransform>();
			component2.anchorMin = Vector2.zero;
			component2.anchorMax = Vector2.one;
			component2.offsetMin = new Vector2(5f, 5f);
			component2.offsetMax = new Vector2(-17f, -5f);
			GameObject val3 = new GameObject("Content", new Type[1] { typeof(RectTransform) });
			val3.transform.SetParent((Transform)(object)component2, false);
			RectTransform component3 = val3.GetComponent<RectTransform>();
			component3.anchorMin = new Vector2(0f, 1f);
			component3.anchorMax = new Vector2(1f, 1f);
			component3.pivot = new Vector2(0.5f, 1f);
			component3.anchoredPosition = Vector2.zero;
			float num = Math.Max(height - 10f, (float)foods.Count * 58f);
			component3.sizeDelta = new Vector2(0f, num);
			if (foods.Count == 0)
			{
				((Graphic)AddLabel((Transform)(object)component3, "No discovered " + FoodTabLabel(tab).ToLowerInvariant() + " foods.", 15, new Vector2(0f, (0f - (height - 10f)) / 2f), width - 35f, 50f)).color = DisabledTextColor;
			}
			for (int i = 0; i < foods.Count; i++)
			{
				ArenaFoodDefinition food = foods[i];
				int num2 = state.SelectedPrefabNames.IndexOf(food.PrefabName);
				string text = ((num2 >= 0) ? ("<color=#FFD27A>[" + (num2 + 1) + "] </color>") : string.Empty);
				string value = text + food.DisplayName + "\n<size=12><color=#FF9C7A>HP " + FormatStat(food.Health) + "</color>   <color=#FFE071>STAM " + FormatStat(food.Stamina) + "</color>   <color=#D7A5FF>EITR " + FormatStat(food.Eitr) + "</color></size>";
				Button obj = AddCardButton((Transform)(object)component3, value, new Vector2(0f, 0f - ((float)i * 58f + 29f)), width - 28f, 54f, delegate
				{
					ToggleFoodSelection(food.PrefabName);
				});
				RectTransform component4 = ((Component)obj).GetComponent<RectTransform>();
				component4.anchorMin = new Vector2(0.5f, 1f);
				component4.anchorMax = new Vector2(0.5f, 1f);
				component4.pivot = new Vector2(0.5f, 0.5f);
				component4.anchoredPosition = new Vector2(0f, 0f - ((float)i * 58f + 29f));
				Image val4 = AddImage(((Component)obj).transform, "FoodIcon", new Vector2((0f - (width - 28f)) / 2f + 25f, 0f), 38f, 38f);
				val4.sprite = ResolveFoodIcon(food.PrefabName);
				((Component)val4).gameObject.SetActive((Object)(object)val4.sprite != (Object)null);
				SetButtonSelected(obj, num2 >= 0);
				Text componentInChildren = ((Component)obj).GetComponentInChildren<Text>(true);
				if ((Object)(object)componentInChildren != (Object)null)
				{
					componentInChildren.fontSize = 14;
					componentInChildren.alignment = (TextAnchor)3;
					RectTransform rectTransform = ((Graphic)componentInChildren).rectTransform;
					rectTransform.anchorMin = Vector2.zero;
					rectTransform.anchorMax = Vector2.one;
					rectTransform.offsetMin = new Vector2(49f, 2f);
					rectTransform.offsetMax = new Vector2(-5f, -2f);
				}
			}
			GameObject val5 = new GameObject("Scrollbar", new Type[3]
			{
				typeof(RectTransform),
				typeof(Image),
				typeof(Scrollbar)
			});
			val5.transform.SetParent(val.transform, false);
			RectTransform component5 = val5.GetComponent<RectTransform>();
			component5.anchorMin = new Vector2(1f, 0f);
			component5.anchorMax = new Vector2(1f, 1f);
			component5.pivot = new Vector2(1f, 0.5f);
			component5.offsetMin = new Vector2(-13f, 5f);
			component5.offsetMax = new Vector2(-4f, -5f);
			((Graphic)val5.GetComponent<Image>()).color = new Color(0.12f, 0.09f, 0.06f, 0.9f);
			GameObject val6 = new GameObject("Handle", new Type[2]
			{
				typeof(RectTransform),
				typeof(Image)
			});
			val6.transform.SetParent(val5.transform, false);
			RectTransform component6 = val6.GetComponent<RectTransform>();
			component6.anchorMin = Vector2.zero;
			component6.anchorMax = Vector2.one;
			component6.offsetMin = Vector2.zero;
			component6.offsetMax = Vector2.zero;
			Image component7 = val6.GetComponent<Image>();
			((Graphic)component7).color = SectionColor;
			Scrollbar component8 = val5.GetComponent<Scrollbar>();
			component8.handleRect = component6;
			((Selectable)component8).targetGraphic = (Graphic)(object)component7;
			component8.direction = (Direction)2;
			ScrollRect component9 = val.GetComponent<ScrollRect>();
			component9.content = component3;
			component9.viewport = component2;
			component9.horizontal = false;
			component9.vertical = (float)foods.Count * 58f > height - 10f;
			component9.movementType = (MovementType)2;
			component9.inertia = true;
			component9.decelerationRate = 0.12f;
			component9.scrollSensitivity = 300f;
			component9.verticalScrollbar = component8;
			component9.verticalScrollbarVisibility = (ScrollbarVisibility)1;
			component9.verticalNormalizedPosition = Mathf.Clamp01(normalizedPosition);
			val5.SetActive(component9.vertical);
			return component9;
		}

		private static void CaptureFoodScrollPositions(FoodPreparationState state)
		{
			if (state?.ScrollRects == null || state.ScrollPositions == null)
			{
				return;
			}
			for (int i = 0; i < state.ScrollRects.Length && i < state.ScrollPositions.Length; i++)
			{
				ScrollRect val = state.ScrollRects[i];
				if ((Object)(object)val != (Object)null)
				{
					state.ScrollPositions[i] = val.verticalNormalizedPosition;
				}
			}
		}

		private static ArenaFoodTab FoodTab(ArenaFoodDefinition food)
		{
			return ArenaFoodIndexPolicy.Classify(food?.Health ?? 0f, food?.Stamina ?? 0f, food?.Eitr ?? 0f);
		}

		private static string FoodTabLabel(ArenaFoodTab tab)
		{
			return tab switch
			{
				ArenaFoodTab.Stamina => "Stamina", 
				ArenaFoodTab.Eitr => "Eitr", 
				_ => "Health", 
			};
		}

		private static void ToggleFoodSelection(string prefabName)
		{
			FoodPreparationState foodPreparation = _foodPreparation;
			if (foodPreparation != null && !string.IsNullOrWhiteSpace(prefabName))
			{
				if (foodPreparation.SelectedPrefabNames.Remove(prefabName))
				{
					BuildFoodPreparation();
					return;
				}
				if (foodPreparation.SelectedPrefabNames.Count >= 3)
				{
					ShowMessage("Remove one selected food before choosing another.");
					return;
				}
				foodPreparation.SelectedPrefabNames.Add(prefabName);
				BuildFoodPreparation();
			}
		}

		private static void ConfirmFoodPreparation()
		{
			FoodPreparationState foodPreparation = _foodPreparation;
			if (foodPreparation == null || foodPreparation.SelectedPrefabNames.Count != 3)
			{
				ShowMessage("Choose exactly three discovered foods.");
				return;
			}
			Func<IList<string>, bool> foodPreparationConfirmed = FoodPreparationConfirmed;
			if (foodPreparationConfirmed != null && foodPreparationConfirmed(new List<string>(foodPreparation.SelectedPrefabNames)))
			{
				CloseModal();
			}
		}

		private static void CancelFoodPreparation()
		{
			FoodPreparationCancelled?.Invoke();
			CloseModal();
		}

		private static Sprite ResolveFoodIcon(string prefabName)
		{
			ObjectDB instance = ObjectDB.instance;
			GameObject obj = ((instance != null) ? instance.GetItemPrefab(prefabName) : null);
			if (obj == null)
			{
				return null;
			}
			ItemDrop component = obj.GetComponent<ItemDrop>();
			if (component == null)
			{
				return null;
			}
			ItemData itemData = component.m_itemData;
			if (itemData == null)
			{
				return null;
			}
			return itemData.GetIcon();
		}

		private static string FormatStat(float value)
		{
			return Math.Max(0, Mathf.RoundToInt(value)).ToString(CultureInfo.InvariantCulture);
		}

		public static void RenderSnapshot(ArenaClientSnapshot snapshot)
		{
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			if (snapshot == null)
			{
				DestroyHud();
				return;
			}
			if (!IsHudPhase(snapshot.Phase) || !ShouldDisplayHud(snapshot))
			{
				if (string.Equals(_hudArenaId, snapshot.ArenaId, StringComparison.Ordinal))
				{
					DestroyHud();
				}
				return;
			}
			if (!CanDraw())
			{
				DestroyHud();
				return;
			}
			if ((Object)(object)_hudRoot == (Object)null)
			{
				_hudRoot = GUIManager.Instance.CreateWoodpanel(GUIManager.CustomGUIFront.transform, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(0f, -105f), 610f, 155f);
				((Object)_hudRoot).name = "ArenaGuard_Hud";
				_hudText = AddLabel(_hudRoot.transform, string.Empty, 20, new Vector2(0f, 18f), 570f, 90f);
				_forfeitButton = AddButton(_hudRoot.transform, "Forfeit", new Vector2(0f, -52f), 155f, 36f, delegate
				{
					ForfeitRequested?.Invoke();
				});
			}
			_activeArenaId = snapshot.ArenaId ?? string.Empty;
			_hudArenaId = _activeArenaId;
			Player localPlayer = Player.m_localPlayer;
			bool active = (Object)(object)localPlayer != (Object)null && snapshot.CombatantPlayerId == localPlayer.GetPlayerID() && IsForfeitPhase(snapshot.Phase);
			if ((Object)(object)_forfeitButton != (Object)null)
			{
				((Component)_forfeitButton).gameObject.SetActive(active);
			}
			_hudSnapshot = snapshot;
			_hudElapsedBaseMilliseconds = snapshot.ElapsedMilliseconds;
			_hudElapsedBaseTime = Time.unscaledTime;
			_nextHudTimerRefreshTime = _hudElapsedBaseTime + 0.1f;
			RefreshHudText(snapshot.ElapsedMilliseconds);
		}

		private static void RefreshHudText(long elapsedMilliseconds)
		{
			ArenaClientSnapshot hudSnapshot = _hudSnapshot;
			if (hudSnapshot != null && !((Object)(object)_hudText == (Object)null))
			{
				StringBuilder stringBuilder = new StringBuilder();
				stringBuilder.Append(string.IsNullOrWhiteSpace(hudSnapshot.ArenaName) ? "Arena" : hudSnapshot.ArenaName);
				stringBuilder.Append(" — ").Append(hudSnapshot.Phase);
				if (!string.IsNullOrWhiteSpace(hudSnapshot.CombatantName))
				{
					stringBuilder.Append("\nCombatant: ").Append(hudSnapshot.CombatantName);
				}
				if (hudSnapshot.EncounterCount > 0)
				{
					stringBuilder.Append("   Opponent ").Append(Math.Min(hudSnapshot.EncounterIndex + 1, hudSnapshot.EncounterCount)).Append('/')
						.Append(hudSnapshot.EncounterCount);
				}
				if (hudSnapshot.CurrentEncounter != null)
				{
					stringBuilder.Append(" — ").Append(hudSnapshot.CurrentEncounter.CreatureKey).Append(" (")
						.Append(StarLabel(hudSnapshot.CurrentEncounter.Stars))
						.Append(")")
						.Append(" x")
						.Append(hudSnapshot.CurrentEncounter.Quantity);
				}
				if (hudSnapshot.CountdownSeconds > 0)
				{
					string value = ((hudSnapshot.Phase == SessionPhase.Staging) ? "Securing loadout — start timeout " : ((hudSnapshot.Phase == SessionPhase.Victory) ? "Returning in " : "Next fight in "));
					stringBuilder.Append("\n").Append(value).Append(hudSnapshot.CountdownSeconds)
						.Append('s');
				}
				stringBuilder.Append("   Fight time ").Append(FormatTime(elapsedMilliseconds));
				if (hudSnapshot.QueuePosition > 0)
				{
					stringBuilder.Append("\nQueue position ").Append(hudSnapshot.QueuePosition).Append('/')
						.Append(hudSnapshot.QueueLength);
				}
				_hudText.text = stringBuilder.ToString();
			}
		}

		public static void ShowLeaderboard(string title, IEnumerable<LeaderboardEntry> entries)
		{
			//IL_0147: Unknown result type (might be due to invalid IL or missing references)
			//IL_017b: Unknown result type (might be due to invalid IL or missing references)
			if (!CanDraw())
			{
				return;
			}
			CloseModal();
			_modalRoot = CreatePanel(string.IsNullOrWhiteSpace(title) ? "Server Leaderboard" : title, 760f, 680f);
			StringBuilder stringBuilder = new StringBuilder();
			int num = 0;
			foreach (LeaderboardEntry item in (entries ?? Enumerable.Empty<LeaderboardEntry>()).Take(18))
			{
				num++;
				stringBuilder.Append(num.ToString(CultureInfo.InvariantCulture).PadLeft(2)).Append(". ").Append(string.IsNullOrWhiteSpace(item.PlayerName) ? "Unknown player" : item.PlayerName);
				if (item.Completed)
				{
					stringBuilder.Append(" — ").Append(FormatTime(item.ElapsedMilliseconds));
				}
				else
				{
					stringBuilder.Append(" — reached stage ").Append(item.FurthestEncounterIndex + 1);
				}
				stringBuilder.Append(" — ").Append(FormatLeaderboardDate(item.RecordedUtc)).Append('\n');
			}
			if (num == 0)
			{
				stringBuilder.Append("No results have been recorded for this challenge yet.");
			}
			AddLabel(_modalRoot.transform, stringBuilder.ToString(), 19, new Vector2(0f, 5f), 680f, 540f).alignment = (TextAnchor)0;
			AddButton(_modalRoot.transform, "Close", new Vector2(0f, -285f), 180f, 45f, CloseModal);
		}

		public static void ReceiveLeaderboard(LeaderboardKey key, IEnumerable<LeaderboardEntry> entries)
		{
			if (!_combinedLeaderboardActive || key == null || key.CapMode != _leaderboardCapMode || (key.CapMode == ProgressionCapMode.Biome && key.SelectedBiome != _leaderboardSelectedBiome))
			{
				return;
			}
			List<LeaderboardEntry> list = (entries ?? Enumerable.Empty<LeaderboardEntry>()).Take(18).ToList();
			if (key.Mode == ChallengeMode.BiomeLadder)
			{
				_biomeLeaderboardEntries = list;
			}
			else
			{
				if (key.Mode != ChallengeMode.StarLadder)
				{
					return;
				}
				_starLeaderboardEntries = list;
			}
			RenderCombinedLeaderboard();
		}

		private static void RenderCombinedLeaderboard()
		{
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0139: Unknown result type (might be due to invalid IL or missing references)
			//IL_0169: Unknown result type (might be due to invalid IL or missing references)
			//IL_019d: Unknown result type (might be due to invalid IL or missing references)
			if (_combinedLeaderboardActive && CanDraw())
			{
				Vector2 position = (((Object)(object)_modalRoot != (Object)null && string.Equals(((Object)_modalRoot).name, "ArenaGuard_ARENALEADERBOARD", StringComparison.Ordinal)) ? GetPanelPosition(_modalRoot) : Vector2.zero);
				Destroy(ref _creaturePickerRoot);
				Destroy(ref _modalRoot);
				_challengeMenu = null;
				_modalRoot = CreatePanel("ARENA LEADERBOARD", 760f, 680f, preserveExistingInputBlock: true);
				SetPanelPosition(_modalRoot, position);
				string text = ((_leaderboardCapMode == ProgressionCapMode.Gauntlet) ? "GAUNTLET • EVERY BIOME" : ("BIOME • " + BiomeLabel(_leaderboardSelectedBiome).ToUpperInvariant()));
				AddSectionLabel(_modalRoot.transform, "BIOME LADDER • " + text, new Vector2(0f, 255f), 680f);
				AddLabel(_modalRoot.transform, FormatLeaderboardSection(_biomeLeaderboardEntries), 17, new Vector2(0f, 133f), 660f, 205f).alignment = (TextAnchor)0;
				AddSectionLabel(_modalRoot.transform, "STAR LADDER • " + text, new Vector2(0f, 12f), 680f);
				AddLabel(_modalRoot.transform, FormatLeaderboardSection(_starLeaderboardEntries), 17, new Vector2(0f, -110f), 660f, 205f).alignment = (TextAnchor)0;
				AddButton(_modalRoot.transform, "Close", new Vector2(0f, -292f), 180f, 42f, CloseCombinedLeaderboard);
				_modalRoot.transform.SetAsLastSibling();
			}
		}

		private static string FormatLeaderboardSection(List<LeaderboardEntry> entries)
		{
			if (entries == null)
			{
				return "Loading…";
			}
			if (entries.Count == 0)
			{
				return "No results have been recorded for this ladder yet.";
			}
			StringBuilder stringBuilder = new StringBuilder();
			int num = 0;
			foreach (LeaderboardEntry item in entries.Take(8))
			{
				num++;
				stringBuilder.Append(num.ToString(CultureInfo.InvariantCulture).PadLeft(2)).Append(". ").Append(string.IsNullOrWhiteSpace(item.PlayerName) ? "Unknown player" : item.PlayerName);
				if (item.Completed)
				{
					stringBuilder.Append(" — ").Append(FormatTime(item.ElapsedMilliseconds));
				}
				else
				{
					stringBuilder.Append(" — stage ").Append(item.FurthestEncounterIndex + 1);
				}
				stringBuilder.Append(" — ").Append(FormatLeaderboardDate(item.RecordedUtc)).Append('\n');
			}
			return stringBuilder.ToString();
		}

		private static string FormatLeaderboardDate(DateTime recordedUtc)
		{
			if (recordedUtc == default(DateTime))
			{
				return "date unavailable";
			}
			return ((recordedUtc.Kind == DateTimeKind.Utc) ? recordedUtc : recordedUtc.ToUniversalTime()).ToString("yyyy-MM-dd HH:mm 'UTC'", CultureInfo.InvariantCulture);
		}

		private static void CloseCombinedLeaderboard()
		{
			_combinedLeaderboardActive = false;
			_biomeLeaderboardEntries = null;
			_starLeaderboardEntries = null;
			CloseModal();
		}

		public static void CloseArenaUi()
		{
			CloseModal();
			CloseQueuePrompt();
			DestroyHud();
			CreatureIconCache.Clear();
			_combinedLeaderboardActive = false;
			_biomeLeaderboardEntries = null;
			_starLeaderboardEntries = null;
			_activeArenaId = string.Empty;
		}

		public static void OnArenaRemoved(string arenaId)
		{
			if (string.Equals(_activeArenaId, arenaId, StringComparison.Ordinal) || string.Equals(_hudArenaId, arenaId, StringComparison.Ordinal) || string.Equals(_queueArenaId, arenaId, StringComparison.Ordinal))
			{
				CloseArenaUi();
			}
		}

		public static void CloseQueuePromptForArena(string arenaId)
		{
			if (string.Equals(_queueArenaId, arenaId, StringComparison.Ordinal))
			{
				CloseQueuePrompt();
			}
		}

		internal static void DriverUpdate()
		{
			if (((Object)(object)_modalRoot != (Object)null || (Object)(object)_queueRoot != (Object)null) && Input.GetKeyDown((KeyCode)27))
			{
				if (_foodPreparation != null)
				{
					CancelFoodPreparation();
				}
				else if ((Object)(object)_creaturePickerRoot != (Object)null)
				{
					CloseCreaturePicker();
				}
				else if ((Object)(object)_biomePickerRoot != (Object)null)
				{
					CloseBiomePicker();
				}
				else
				{
					CloseModal();
					CloseQueuePrompt();
				}
			}
			UpdateQueuePrompt();
			UpdateFoodPreparationTimer();
			UpdateLiveHudTimer();
			UpdateSetupVisibilityButton();
			UpdateAdminPermissionButtons();
		}

		private static bool CanDraw()
		{
			if (GUIManager.IsHeadless() || (Object)(object)GUIManager.CustomGUIFront == (Object)null)
			{
				return false;
			}
			EnsureDriver();
			return true;
		}

		private static void EnsureDriver()
		{
			if (!((Object)(object)GUIManager.CustomGUIFront == (Object)null) && !((Object)(object)_driverHost == (Object)(object)GUIManager.CustomGUIFront))
			{
				GUIManager.CustomGUIFront.AddComponent<ArenaUiDriver>();
				_driverHost = GUIManager.CustomGUIFront;
			}
		}

		private static GameObject CreatePanel(string title, float width, float height, bool preserveExistingInputBlock = false)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			GameObject obj = GUIManager.Instance.CreateWoodpanel(GUIManager.CustomGUIFront.transform, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), Vector2.zero, width, height);
			((Object)obj).name = "ArenaGuard_" + title.Replace(" ", string.Empty);
			AddLabel(obj.transform, title, 30, new Vector2(0f, height / 2f - 48f), width - 50f, 45f, bold: true);
			if (!preserveExistingInputBlock || !_inputBlocked)
			{
				SetInputBlocked(block: true);
			}
			return obj;
		}

		private static Text AddLabel(Transform parent, string value, int size, Vector2 position, float width, float height, bool bold = false)
		{
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			Font val = (bold ? GUIManager.Instance.AveriaSerifBold : GUIManager.Instance.AveriaSerif);
			Text component = GUIManager.Instance.CreateText(value, parent, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), position, val, size, Color.white, true, Color.black, width, height, false).GetComponent<Text>();
			component.alignment = (TextAnchor)4;
			return component;
		}

		private static Text AddSectionLabel(Transform parent, string value, Vector2 position, float width)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			Text obj = AddLabel(parent, "──  " + value + "  ──", 17, position, width, 30f, bold: true);
			((Graphic)obj).color = SectionColor;
			return obj;
		}

		private static Dropdown AddDropdown(Transform parent, Vector2 position, float width, params string[] values)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			Dropdown component = GUIManager.Instance.CreateDropDown(parent, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), position, 18, width, 42f).GetComponent<Dropdown>();
			component.ClearOptions();
			component.AddOptions(((IEnumerable<string>)values).Select((Func<string, OptionData>)((string value) => new OptionData(value))).ToList());
			return component;
		}

		private static InputField AddInput(Transform parent, string value, Vector2 position, float width, float height, ContentType contentType)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			InputField component = GUIManager.Instance.CreateInputField(parent, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), position, contentType, string.Empty, 18, width, height).GetComponent<InputField>();
			component.text = value;
			return component;
		}

		private static Button AddButton(Transform parent, string value, Vector2 position, float width, float height, Action click)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Expected O, but got Unknown
			Button component = GUIManager.Instance.CreateButton(value, parent, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), position, width, height).GetComponent<Button>();
			((UnityEvent)component.onClick).AddListener((UnityAction)delegate
			{
				click();
			});
			return component;
		}

		private static Button AddModeCard(Transform parent, string value, Vector2 position, Action click)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			return AddCardButton(parent, value, position, 176f, 104f, click);
		}

		private static Button AddCreatureCard(Transform parent, CreatureDefinition creature, Vector2 position, float width, float height, Action click)
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_017f: Unknown result type (might be due to invalid IL or missing references)
			string value = creature.DisplayName + (creature.IsMiniboss ? "\n<size=13><color=#E8A43A>MINIBOSS</color></size>" : string.Empty);
			Button val = AddCardButton(parent, value, position, width, height, click);
			Text componentInChildren = ((Component)val).GetComponentInChildren<Text>(true);
			if ((Object)(object)componentInChildren != (Object)null)
			{
				RectTransform rectTransform = ((Graphic)componentInChildren).rectTransform;
				rectTransform.anchorMin = new Vector2(0f, 0f);
				rectTransform.anchorMax = new Vector2(1f, 0f);
				rectTransform.pivot = new Vector2(0.5f, 0f);
				rectTransform.anchoredPosition = new Vector2(0f, 5f);
				rectTransform.sizeDelta = new Vector2(-8f, 39f);
				componentInChildren.fontSize = 15;
				componentInChildren.resizeTextForBestFit = true;
				componentInChildren.resizeTextMinSize = 11;
				componentInChildren.resizeTextMaxSize = 15;
			}
			Sprite val2 = ResolveCreatureIcon(creature.IconPrefabName);
			Sprite val3 = ResolveCreatureIcon(creature.SecondaryIconPrefabName);
			float num = (((Object)(object)val3 == (Object)null) ? 0f : (-25f));
			Image obj = AddImage(((Component)val).transform, "CreatureIcon", new Vector2(num, 22f), ((Object)(object)val3 == (Object)null) ? 62f : 50f, ((Object)(object)val3 == (Object)null) ? 62f : 50f);
			obj.sprite = val2;
			((Component)obj).gameObject.SetActive((Object)(object)val2 != (Object)null);
			if ((Object)(object)val3 != (Object)null)
			{
				AddImage(((Component)val).transform, "SecondaryCreatureIcon", new Vector2(25f, 22f), 50f, 50f).sprite = val3;
			}
			return val;
		}

		private static Image AddImage(Transform parent, string name, Vector2 position, float width, float height)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject(name, new Type[1] { typeof(RectTransform) });
			val.transform.SetParent(parent, false);
			RectTransform component = val.GetComponent<RectTransform>();
			component.anchorMin = new Vector2(0.5f, 0.5f);
			component.anchorMax = new Vector2(0.5f, 0.5f);
			component.pivot = new Vector2(0.5f, 0.5f);
			component.anchoredPosition = position;
			component.sizeDelta = new Vector2(width, height);
			Image obj = val.AddComponent<Image>();
			obj.preserveAspect = true;
			((Graphic)obj).raycastTarget = false;
			((Graphic)obj).color = Color.white;
			return obj;
		}

		private static void SetCreatureIcons(Image primary, Image secondary, CreatureDefinition creature)
		{
			Sprite val = ResolveCreatureIcon(creature?.IconPrefabName);
			Sprite val2 = ResolveCreatureIcon(creature?.SecondaryIconPrefabName);
			if ((Object)(object)primary != (Object)null)
			{
				primary.sprite = val;
				((Component)primary).gameObject.SetActive((Object)(object)val != (Object)null);
			}
			if ((Object)(object)secondary != (Object)null)
			{
				secondary.sprite = val2;
				((Component)secondary).gameObject.SetActive((Object)(object)val2 != (Object)null);
			}
		}

		private static Sprite ResolveCreatureIcon(string prefabName)
		{
			if (string.IsNullOrWhiteSpace(prefabName))
			{
				return null;
			}
			if (CreatureIconCache.TryGetValue(prefabName, out var value) && (Object)(object)value != (Object)null)
			{
				return value;
			}
			ObjectDB instance = ObjectDB.instance;
			object obj = ((instance != null) ? instance.GetItemPrefab(prefabName) : null);
			if (obj == null)
			{
				ZNetScene instance2 = ZNetScene.instance;
				obj = ((instance2 != null) ? instance2.GetPrefab(prefabName) : null);
			}
			object obj2;
			if (obj == null)
			{
				obj2 = null;
			}
			else
			{
				ItemDrop component = ((GameObject)obj).GetComponent<ItemDrop>();
				if (component == null)
				{
					obj2 = null;
				}
				else
				{
					ItemData itemData = component.m_itemData;
					obj2 = ((itemData != null) ? itemData.GetIcon() : null);
				}
			}
			Sprite val = (Sprite)obj2;
			if ((Object)(object)val != (Object)null)
			{
				CreatureIconCache[prefabName] = val;
			}
			return val;
		}

		private static Button AddCardButton(Transform parent, string value, Vector2 position, float width, float height, Action click)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			Button obj = AddButton(parent, value, position, width, height, click);
			Text componentInChildren = ((Component)obj).GetComponentInChildren<Text>(true);
			if ((Object)(object)componentInChildren != (Object)null)
			{
				componentInChildren.fontSize = 18;
				componentInChildren.alignment = (TextAnchor)4;
				componentInChildren.supportRichText = true;
			}
			return obj;
		}

		private static void SetButtonSelected(Button button, bool selected)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)button == (Object)null))
			{
				ColorBlock colors = ((Selectable)button).colors;
				((ColorBlock)(ref colors)).normalColor = (selected ? SelectedButtonColor : NormalButtonColor);
				((ColorBlock)(ref colors)).highlightedColor = (Color)(selected ? new Color(1f, 0.72f, 0.3f, 1f) : Color.white);
				((ColorBlock)(ref colors)).selectedColor = ((ColorBlock)(ref colors)).highlightedColor;
				((Selectable)button).colors = colors;
			}
		}

		private static void SetPanelPosition(GameObject panel, Vector2 position)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			RectTransform val = ((panel != null) ? panel.GetComponent<RectTransform>() : null);
			if ((Object)(object)val != (Object)null)
			{
				val.anchoredPosition = position;
			}
		}

		private static Vector2 GetPanelPosition(GameObject panel)
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			RectTransform val = ((panel != null) ? panel.GetComponent<RectTransform>() : null);
			if (!((Object)(object)val == (Object)null))
			{
				return val.anchoredPosition;
			}
			return Vector2.zero;
		}

		private static void UpdateQueuePrompt()
		{
			if (!((Object)(object)_queueRoot == (Object)null) && !((Object)(object)_queueText == (Object)null))
			{
				int num = Math.Max(0, (int)Math.Ceiling((_queueDeadlineUtc - DateTime.UtcNow).TotalSeconds));
				_queueText.text = "Accept within " + num + " seconds or you will move to the back of the queue.";
				if (num == 0)
				{
					CloseQueuePrompt();
				}
			}
		}

		private static void UpdateFoodPreparationTimer()
		{
			FoodPreparationState foodPreparation = _foodPreparation;
			if (!((Object)(object)foodPreparation?.DeadlineLabel == (Object)null))
			{
				int num = Math.Max(0, (int)Math.Ceiling((foodPreparation.DeadlineUtc - DateTime.UtcNow).TotalSeconds));
				foodPreparation.DeadlineLabel.text = "Choose exactly three foods your character has discovered.  Ready in " + num + "s";
			}
		}

		private static void CloseModal()
		{
			_combinedLeaderboardActive = false;
			_biomeLeaderboardEntries = null;
			_starLeaderboardEntries = null;
			Destroy(ref _creaturePickerRoot);
			Destroy(ref _biomePickerRoot);
			Destroy(ref _modalRoot);
			_challengeMenu = null;
			_setupVisibilityButton = null;
			_terrainPermissionButton = null;
			_buildingPermissionButton = null;
			_pickupPermissionButton = null;
			_foodPreparation = null;
			RefreshInputBlock();
		}

		private static string SetupVisibilityButtonText()
		{
			return (ArenaWorldObjects.AdminSetupVisualsEnabled ? "Hide" : "Show") + " setup/spawn visuals (" + ArenaWorldObjects.AdminSetupVisualShortcut + ")";
		}

		private static void UpdateSetupVisibilityButton()
		{
			if (!((Object)(object)_setupVisibilityButton == (Object)null))
			{
				Text componentInChildren = ((Component)_setupVisibilityButton).GetComponentInChildren<Text>(true);
				if ((Object)(object)componentInChildren != (Object)null)
				{
					componentInChildren.text = SetupVisibilityButtonText();
				}
			}
		}

		private static void ToggleAdminPermission(string arenaId, ArenaAdminPermissionKind permission)
		{
			if (AdminMutationRequested == null)
			{
				ShowMessage("Arena administration is not connected to the server yet.");
				return;
			}
			bool enabled = !(AdminPermissionResolver?.Invoke(permission) ?? false);
			ArenaUiAdminMutationKind kind = permission switch
			{
				ArenaAdminPermissionKind.Terrain => ArenaUiAdminMutationKind.SetTerrainPermission, 
				ArenaAdminPermissionKind.Building => ArenaUiAdminMutationKind.SetBuildingPermission, 
				_ => ArenaUiAdminMutationKind.SetPickupPermission, 
			};
			AdminMutationRequested(new ArenaUiAdminMutation
			{
				ArenaId = arenaId,
				Kind = kind,
				Enabled = enabled
			});
		}

		private static string PermissionButtonText(ArenaAdminPermissionKind permission)
		{
			bool flag = AdminPermissionResolver?.Invoke(permission) ?? false;
			return permission switch
			{
				ArenaAdminPermissionKind.Building => "Build & demolish", 
				ArenaAdminPermissionKind.Terrain => "Terrain editing", 
				_ => "Dropped-item pickup", 
			} + ": " + (flag ? "ALLOWED" : "BLOCKED");
		}

		private static void UpdateAdminPermissionButtons()
		{
			UpdateButtonLabel(_terrainPermissionButton, PermissionButtonText(ArenaAdminPermissionKind.Terrain));
			UpdateButtonLabel(_buildingPermissionButton, PermissionButtonText(ArenaAdminPermissionKind.Building));
			UpdateButtonLabel(_pickupPermissionButton, PermissionButtonText(ArenaAdminPermissionKind.DroppedItemPickup));
		}

		private static void UpdateButtonLabel(Button button, string value)
		{
			if (!((Object)(object)button == (Object)null))
			{
				Text componentInChildren = ((Component)button).GetComponentInChildren<Text>(true);
				if ((Object)(object)componentInChildren != (Object)null)
				{
					componentInChildren.text = value;
				}
			}
		}

		private static void CloseQueuePrompt()
		{
			Destroy(ref _queueRoot);
			_queueText = null;
			_queueArenaId = string.Empty;
			RefreshInputBlock();
		}

		private static void DestroyHud()
		{
			Destroy(ref _hudRoot);
			_hudText = null;
			_forfeitButton = null;
			_hudArenaId = string.Empty;
			_hudSnapshot = null;
			_hudElapsedBaseMilliseconds = 0L;
			_hudElapsedBaseTime = 0f;
			_nextHudTimerRefreshTime = 0f;
		}

		private static void UpdateLiveHudTimer()
		{
			if (_hudSnapshot != null && !((Object)(object)_hudText == (Object)null) && _hudSnapshot.Phase == SessionPhase.Fighting)
			{
				float unscaledTime = Time.unscaledTime;
				if (!(unscaledTime < _nextHudTimerRefreshTime))
				{
					_nextHudTimerRefreshTime = unscaledTime + 0.1f;
					RefreshHudText(_hudElapsedBaseMilliseconds + Math.Max(0L, (long)((unscaledTime - _hudElapsedBaseTime) * 1000f)));
				}
			}
		}

		private static bool IsHudPhase(SessionPhase phase)
		{
			if (phase != SessionPhase.Staging && phase != SessionPhase.Countdown && phase != SessionPhase.Fighting && phase != SessionPhase.Intermission && phase != SessionPhase.Victory && phase != SessionPhase.Defeat && phase != SessionPhase.Forfeit)
			{
				return phase == SessionPhase.Recovering;
			}
			return true;
		}

		private static bool ShouldDisplayHud(ArenaClientSnapshot snapshot)
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null)
			{
				return false;
			}
			if (snapshot.CombatantPlayerId == localPlayer.GetPlayerID() || snapshot.QueuePosition > 0)
			{
				return true;
			}
			Vector3 position = ((Component)localPlayer).transform.position;
			float num = position.x - snapshot.CorePosition.X;
			float num2 = position.z - snapshot.CorePosition.Z;
			return num * num + num2 * num2 <= snapshot.ProtectedRadius * snapshot.ProtectedRadius;
		}

		private static bool IsForfeitPhase(SessionPhase phase)
		{
			if (phase != SessionPhase.Staging && phase != SessionPhase.Countdown && phase != SessionPhase.Fighting)
			{
				return phase == SessionPhase.Intermission;
			}
			return true;
		}

		private static void Destroy(ref GameObject gameObject)
		{
			if ((Object)(object)gameObject != (Object)null)
			{
				Object.Destroy((Object)(object)gameObject);
				gameObject = null;
			}
		}

		private static void RefreshInputBlock()
		{
			SetInputBlocked((Object)(object)_modalRoot != (Object)null || (Object)(object)_creaturePickerRoot != (Object)null || (Object)(object)_biomePickerRoot != (Object)null || (Object)(object)_queueRoot != (Object)null);
		}

		private static void SetInputBlocked(bool block)
		{
			if (_inputBlocked != block)
			{
				GUIManager.BlockInput(block);
				_inputBlocked = block;
			}
		}

		private static void ShowMessage(string text)
		{
			Player localPlayer = Player.m_localPlayer;
			if (localPlayer != null)
			{
				((Character)localPlayer).Message((MessageType)2, text, 0, (Sprite)null);
			}
		}

		private static string StarLabel(StarLevel stars)
		{
			return stars switch
			{
				StarLevel.OneStar => "1 star", 
				StarLevel.TwoStar => "2 stars", 
				_ => "base", 
			};
		}

		private static string BiomeLabel(BiomeTier biome)
		{
			if (biome != BiomeTier.BlackForest)
			{
				return biome.ToString();
			}
			return "Black Forest";
		}

		private static string FormatTime(long milliseconds)
		{
			return ArenaDurationFormatter.FormatHms(milliseconds);
		}
	}
	public sealed class ArenaUiDriver : MonoBehaviour
	{
		private void Update()
		{
			ArenaUi.DriverUpdate();
		}
	}
}
namespace ArenaGuard.Sessions
{
	public sealed class ArenaSessionOptions
	{
		public TimeSpan QueueAcceptanceTimeout = TimeSpan.FromSeconds(30.0);

		public TimeSpan StagingTimeout = TimeSpan.FromSeconds(60.0);

		public TimeSpan BoundaryGracePeriod = TimeSpan.FromSeconds(5.0);

		public TimeSpan VictoryDisplayDuration = TimeSpan.FromSeconds(5.0);
	}
	public sealed class ArenaSessionEngine
	{
		private readonly Func<ChallengeRequest, ChallengePlan> _planFactory;

		private readonly Func<DateTime> _utcNow;

		private readonly ArenaSessionOptions _options;

		private readonly List<QueueEntry> _queue = new List<QueueEntry>();

		private readonly Dictionary<string, ArenaSession> _activeByArena = new Dictionary<string, ArenaSession>(StringComparer.OrdinalIgnoreCase);

		private readonly Dictionary<string, ArenaSession> _sessionsById = new Dictionary<string, ArenaSession>(StringComparer.OrdinalIgnoreCase);

		private readonly Dictionary<long, DateTime> _boundaryDeadlines = new Dictionary<long, DateTime>();

		private readonly Dictionary<string, ChallengePlan> _recoveredPlansByRequestId = new Dictionary<string, ChallengePlan>(StringComparer.OrdinalIgnoreCase);

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

		private readonly List<ArenaEffect> _effects = new List<ArenaEffect>();

		private int _nextQueueSequence = 1;

		public ArenaSessionEngine(Func<ChallengeRequest, ChallengePlan> planFactory, Func<DateTime> utcNow = null, ArenaSessionOptions options = null)
		{
			_planFactory = planFactory ?? throw new ArgumentNullException("planFactory");
			_utcNow = utcNow ?? ((Func<DateTime>)(() => DateTime.UtcNow));
			_options = options ?? new ArenaSessionOptions();
			ValidateOptions(_options);
		}

		public void Enqueue(QueueEntry entry)
		{
			ValidateQueueEntry(entry);
			if (ContainsPlayer(entry.Request.PlayerId))
			{
				throw new InvalidOperationException("A player can only occupy one arena queue or session at a time.");
			}
			if (ContainsRequest(entry.Request.RequestId))
			{
				throw new InvalidOperationException("That challenge request is already queued or active.");
			}
			QueueEntry queueEntry = CloneQueueEntry(entry);
			queueEntry.QueueSequence = _nextQueueSequence++;
			queueEntry.EnqueuedUtc = Now();
			_queue.Add(queueEntry);
			Emit(ArenaEffectType.SetArenaRole, queueEntry.Request.ArenaId, null, queueEntry.Request.PlayerId, null, ArenaRole.Queued.ToString());
			Emit(ArenaEffectType.PersistState, queueEntry.Request.ArenaId, null, queueEntry.Request.PlayerId, null, "Queue joined.");
			TryCallNext(queueEntry.Request.ArenaId, Now());
		}

		public bool AcceptTurn(long playerId)
		{
			ArenaSession arenaSession = FindActiveByPlayer(playerId);
			if (arenaSession == null || arenaSession.Phase != SessionPhase.Called)
			{
				return false;
			}
			DateTime dateTime = Now();
			if (dateTime >= arenaSession.PhaseDeadlineUtc)
			{
				HandleCallTimeout(arenaSession, dateTime);
				return false;
			}
			arenaSession.Phase = SessionPhase.Staging;
			arenaSession.PhaseStartedUtc = dateTime;
			arenaSession.PhaseDeadlineUtc = dateTime.Add(_options.StagingTimeout);
			Emit(ArenaEffectType.SetArenaRole, arenaSession, null, ArenaRole.Combatant.ToString());
			Emit(ArenaEffectType.PersistState, arenaSession, null, "Queue turn accepted.");
			Emit(ArenaEffectType.MoveToStaging, arenaSession, null, "Move called combatant to staging.");
			Emit(ArenaEffectType.SendLocalMessage, arenaSession, null, "Preparing your combat teleport. The arena will start when your loadout is secured.");
			return true;
		}

		public bool EnterCombatFloor(long playerId)
		{
			return EnterCombatFloor(playerId, null);
		}

		public bool EnterCombatFloor(long playerId, PlayerResourceSnapshot resourceSnapshot)
		{
			ArenaSession arenaSession = FindActiveByPlayer(playerId);
			if (arenaSession == null || arenaSession.Phase != SessionPhase.Staging)
			{
				return false;
			}
			DateTime dateTime = Now();
			if (dateTime >= arenaSession.PhaseDeadlineUtc)
			{
				HandleStagingTimeout(arenaSession, dateTime);
				return false;
			}
			if (resourceSnapshot != null && resourceSnapshot.PlayerId != playerId)
			{
				throw new ArgumentException("The resource snapshot belongs to a different player.", "resourceSnapshot");
			}
			arenaSession.ResourceSnapshot = CloneResourceSnapshot(resourceSnapshot);
			arenaSession.EncounterIndex = 0;
			arenaSession.LivingArenaEnemyCount = 0;
			arenaSession.SpawnedEnemyIds.Clear();
			arenaSession.Outcome = SessionOutcome.None;
			arenaSession.SessionStartedUtc = dateTime;
			StartCountdown(arenaSession, SessionPhase.Countdown, dateTime);
			_boundaryDeadlines.Remove(playerId);
			_recoveredPlansByRequestId.Remove(arenaSession.Request.RequestId);
			Emit(ArenaEffectType.PersistState, arenaSession, CurrentEncounter(arenaSession), "Challenge started; persist the snapshot before spawning.");
			Emit(ArenaEffectType.StartCountdown, arenaSession, CurrentEncounter(arenaSession), CountdownMessage(arenaSession));
			EmitAnnouncement(arenaSession, "started " + DescribeMode(arenaSession.Plan.Mode) + ".");
			return true;
		}

		public bool SetResourceSnapshot(long playerId, PlayerResourceSnapshot resourceSnapshot)
		{
			if (resourceSnapshot == null)
			{
				throw new ArgumentNullException("resourceSnapshot");
			}
			if (resourceSnapshot.PlayerId != playerId)
			{
				throw new ArgumentException("The resource snapshot belongs to a different player.", "resourceSnapshot");
			}
			ArenaSession arenaSession = FindActiveByPlayer(playerId);
			if (arenaSession == null || arenaSession.Phase != SessionPhase.Staging || arenaSession.ResourceSnapshot != null)
			{
				return false;
			}
			arenaSession.ResourceSnapshot = CloneResourceSnapshot(resourceSnapshot);
			Emit(ArenaEffectType.PersistState, arenaSession, CurrentEncounterOrNull(arenaSession), "Player resource snapshot captured.");
			return true;
		}

		public void Tick(DateTime utcNow)
		{
			if (utcNow.Kind == DateTimeKind.Local)
			{
				utcNow = utcNow.ToUniversalTime();
			}
			foreach (ArenaSession item in _activeByArena.Values.ToList())
			{
				UpdateElapsed(item, utcNow);
				if (_boundaryDeadlines.TryGetValue(item.Request.PlayerId, out var value) && utcNow >= value)
				{
					EndRun(item, SessionOutcome.BoundaryForfeit, SessionPhase.Forfeit, utcNow, "left the combat boundary and forfeited.", recordResult: true);
				}
				else if (!(item.PhaseDeadlineUtc == DateTime.MinValue) && !(utcNow < item.PhaseDeadlineUtc))
				{
					switch (item.Phase)
					{
					case SessionPhase.Called:
						HandleCallTimeout(item, utcNow);
						break;
					case SessionPhase.Staging:
						HandleStagingTimeout(item, utcNow);
						break;
					case SessionPhase.Countdown:
					case SessionPhase.Intermission:
						BeginEncounter(item, utcNow);
						break;
					case SessionPhase.Victory:
						FinalizeTerminalSession(item, utcNow, wasVictory: true);
						break;
					}
				}
			}
		}

		public void Tick()
		{
			Tick(Now());
		}

		public bool ReportEncounterCleared(string sessionId)
		{
			if (string.IsNullOrWhiteSpace(sessionId))
			{
				return false;
			}
			if (!_sessionsById.TryGetValue(sessionId, out var value) || value.Phase != SessionPhase.Fighting || !IsActive(value))
			{
				return false;
			}
			DateTime dateTime = Now();
			value.LivingArenaEnemyCount = 0;
			value.SpawnedEnemyIds.Clear();
			UpdateElapsed(value, dateTime);
			if (value.EncounterIndex >= value.Plan.Encounters.Count - 1)
			{
				value.Outcome = SessionOutcome.Victory;
				value.Phase = SessionPhase.Victory;
				value.PhaseStartedUtc = dateTime;
				value.PhaseDeadlineUtc = dateTime.Add(_options.VictoryDisplayDuration);
				_boundaryDeadlines.Remove(value.Request.PlayerId);
				Emit(ArenaEffectType.UpdateLeaderboard, value, CurrentEncounter(value), "Record completed challenge.");
				Emit(ArenaEffectType.PersistState, value, CurrentEncounter(value), "Challenge won.");
				EmitAnnouncement(value, "completed " + DescribeMode(value.Plan.Mode) + ".");
				return true;
			}
			value.EncounterIndex++;
			StartCountdown(value, SessionPhase.Intermission, dateTime);
			Emit(ArenaEffectType.PersistState, value, CurrentEncounter(value), "Encounter cleared.");
			Emit(ArenaEffectType.StartCountdown, value, CurrentEncounter(value), CountdownMessage(value));
			return true;
		}

		public bool ReportBoundaryState(long playerId, bool isOutside)
		{
			ArenaSession arenaSession = FindActiveByPlayer(playerId);
			if (arenaSession == null || !IsChallengeInProgress(arenaSession))
			{
				_boundaryDeadlines.Remove(playerId);
				return false;
			}
			if (!isOutside)
			{
				if (_boundaryDeadlines.Remove(playerId))
				{
					Emit(ArenaEffectType.SendLocalMessage, arenaSession, CurrentEncounter(arenaSession), "Boundary warning cleared.");
				}
				return true;
			}
			if (!_boundaryDeadlines.ContainsKey(playerId))
			{
				_boundaryDeadlines[playerId] = Now().Add(_options.BoundaryGracePeriod);
				Emit(ArenaEffectType.SendLocalMessage, arenaSession, CurrentEncounter(arenaSession), "Return to the combat floor within " + (int)_options.BoundaryGracePeriod.TotalSeconds + " seconds or forfeit.");
			}
			return true;
		}

		public bool ReportLethalDamage(long playerId)
		{
			ArenaSession arenaSession = FindActiveByPlayer(playerId);
			if (arenaSession == null || !IsChallengeInProgress(arenaSession))
			{
				return false;
			}
			EndRun(arenaSession, SessionOutcome.Defeat, SessionPhase.Defeat, Now(), "was defeated in the arena.", recordResult: true);
			return true;
		}

		public bool Forfeit(long playerId)
		{
			ArenaSession arenaSession = FindActiveByPlayer(playerId);
			if (arenaSession == null || (arenaSession.Phase != SessionPhase.Staging && !IsChallengeInProgress(arenaSession)))
			{
				return false;
			}
			bool recordResult = arenaSession.SessionStartedUtc != DateTime.MinValue;
			EndRun(arenaSession, SessionOutcome.Forfeit, SessionPhase.Forfeit, Now(), "forfeited the arena challenge.", recordResult);
			return true;
		}

		public int ClearQueue(string arenaId)
		{
			if (string.IsNullOrWhiteSpace(arenaId))
			{
				return 0;
			}
			List<QueueEntry> list = _queue.Where((QueueEntry entry) => string.Equals(entry.Request.ArenaId, arenaId, StringComparison.OrdinalIgnoreCase)).ToList();
			if (list.Count == 0)
			{
				return 0;
			}
			_queue.RemoveAll((QueueEntry entry) => string.Equals(entry.Request.ArenaId, arenaId, StringComparison.OrdinalIgnoreCase));
			foreach (QueueEntry item in list)
			{
				Emit(ArenaEffectType.SetArenaRole, arenaId, null, item.Request.PlayerId, null, ArenaRole.Spectator.ToString());
			}
			Emit(ArenaEffectType.PersistState, arenaId, null, 0L, null, "Administrator cleared the arena queue.");
			return list.Count;
		}

		public bool AbortArena(string arenaId)
		{
			if (string.IsNullOrWhiteSpace(arenaId) || !_activeByArena.TryGetValue(arenaId, out var value))
			{
				return false;
			}
			DateTime dateTime = Now();
			UpdateElapsed(value, dateTime);
			value.Outcome = SessionOutcome.Forfeit;
			value.Phase = SessionPhase.Forfeit;
			value.PhaseStartedUtc = dateTime;
			value.PhaseDeadlineUtc = DateTime.MinValue;
			_boundaryDeadlines.Remove(value.Request.PlayerId);
			EmitAnnouncement(value, "had the arena challenge stopped by an administrator.");
			FinalizeTerminalSession(value, dateTime, wasVictory: false);
			return true;
		}

		public bool Disconnect(long playerId)
		{
			bool flag = _queue.RemoveAll((QueueEntry entry) => entry.Request.PlayerId == playerId) > 0;
			if (flag)
			{
				Emit(ArenaEffectType.SetArenaRole, null, null, playerId, null, ArenaRole.Spectator.ToString());
				Emit(ArenaEffectType.PersistState, null, null, playerId, null, "Disconnected player removed from queue.");
			}
			ArenaSession arenaSession = FindActiveByPlayer(playerId);
			if (arenaSession == null)
			{
				return flag;
			}
			bool recordResult = arenaSession.SessionStartedUtc != DateTime.MinValue;
			EndRun(arenaSession, SessionOutcome.Disconnect, SessionPhase.Recovering, Now(), "disconnected; the challenge was cancelled.", recordResult);
			return true;
		}

		public void RecoverAfterRestart(PersistedWorldState state)
		{
			if (state == null)
			{
				throw new ArgumentNullException("state");
			}
			_queue.Clear();
			_activeByArena.Clear();
			_sessionsById.Clear();
			_boundaryDeadlines.Clear();
			_recoveredPlansByRequestId.Clear();
			_originGateBySessionId.Clear();
			_effects.Clear();
			_nextQueueSequence = 1;
			HashSet<long> hashSet = new HashSet<long>();
			HashSet<string> hashSet2 = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
			HashSet<string> hashSet3 = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
			foreach (ArenaSession item in state.InterruptedSessions ?? new List<ArenaSession>())
			{
				if (IsRecoverable(item) && hashSet.Add(item.Request.PlayerId) && hashSet2.Add(item.Request.RequestId))
				{
					ArenaSession arenaSession = CloneSession(item);
					arenaSession.Outcome = SessionOutcome.ServerRestart;
					arenaSession.Phase = SessionPhase.Recovering;
					arenaSession.PhaseDeadlineUtc = DateTime.MinValue;
					_sessionsById[arenaSession.SessionId] = arenaSession;
					Emit(ArenaEffectType.DespawnSessionEnemies, arenaSession, CurrentEncounterOrNull(arenaSession), "Remove enemies left by the interrupted session.");
					if (arenaSession.ResourceSnapshot != null)
					{
						Emit(ArenaEffectType.RestorePlayerState, arenaSession, CurrentEncounterOrNull(arenaSession), "Restore the pre-restart resource snapshot.");
					}
					Emit(ArenaEffectType.MoveToStaging, arenaSession, CurrentEncounterOrNull(arenaSession), "Return the interrupted combatant to staging.");
					Emit(ArenaEffectType.SetArenaRole, arenaSession, null, ArenaRole.Queued.ToString());
					Emit(ArenaEffectType.SendLocalMessage, arenaSession, null, "The server restarted. Your challenge will restart from the beginning.");
					_recoveredPlansByRequestId[arenaSession.Request.RequestId] = ClonePlan(arenaSession.Plan);
					_queue.Add(new QueueEntry
					{
						Request = CloneRequest(arenaSession.Request),
						OriginGateId = string.Empty,
						QueueSequence = _nextQueueSequence++,
						EnqueuedUtc = Now()
					});
					hashSet3.Add(arenaSession.ArenaId);
				}
			}
			foreach (QueueEntry item2 in from item in state.Queue ?? new List<QueueEntry>()
				orderby item.QueueSequence, item.EnqueuedUtc
				select item)
			{
				try
				{
					ValidateQueueEntry(item2);
				}
				catch (ArgumentException)
				{
					continue;
				}
				if (hashSet.Add(item2.Request.PlayerId) && hashSet2.Add(item2.Request.RequestId))
				{
					QueueEntry queueEntry = CloneQueueEntry(item2);
					queueEntry.QueueSequence = _nextQueueSequence++;
					_queue.Add(queueEntry);
					hashSet3.Add(queueEntry.Request.ArenaId);
				}
			}
			Emit(ArenaEffectType.PersistState, null, null, 0L, null, "Restart recovery queue rebuilt.");
			foreach (string item3 in hashSet3)
			{
				TryCallNext(item3, Now());
			}
		}

		public void ApplyEffectResult(ArenaEffect effect, bool succeeded)
		{
			if (effect == null)
			{
				throw new ArgumentNullException("effect");
			}
			ArenaSession value2;
			if (succeeded)
			{
				if (effect.Type == ArenaEffectType.SpawnEncounter && _sessionsById.TryGetValue(effect.SessionId ?? string.Empty, out var value) && value.Phase == SessionPhase.Fighting && effect.Encounter != null)
				{
					value.LivingArenaEnemyCount = effect.Encounter.Quantity;
				}
			}
			else if (!string.IsNullOrEmpty(effect.SessionId) && _sessionsById.TryGetValue(effect.SessionId, out value2))
			{
				if (effect.Type == ArenaEffectType.SpawnEncounter && IsActive(value2))
				{
					EndRun(value2, SessionOutcome.RuntimeError, SessionPhase.Defeat, Now(), "could not start an arena encounter because spawning failed.", recordResult: true);
				}
				else if (effect.Type == ArenaEffectType.RestorePlayerState)
				{
					value2.Phase = SessionPhase.Recovering;
					Emit(ArenaEffectType.SendLocalMessage, value2, null, "ArenaGuard could not restore player state automatically; an administrator must retry recovery.");
					Emit(ArenaEffectType.PersistState, value2, null, "Player restoration requires recovery.");
				}
			}
		}

		public IList<ArenaEffect> DrainEffects()
		{
			List<ArenaEffect> result = _effects.Select(CloneEffect).ToList();
			_effects.Clear();
			return result;
		}

		public IList<QueueEntry> GetQueueSnapshot()
		{
			return _queue.Select(CloneQueueEntry).ToList();
		}

		public IList<ArenaSession> GetActiveSessions()
		{
			return _activeByArena.Values.Select(CloneSession).ToList();
		}

		public bool TryGetActiveSession(string arenaId, out ArenaSession session)
		{
			if (!string.IsNullOrWhiteSpace(arenaId) && _activeByArena.TryGetValue(arenaId, out var value))
			{
				session = CloneSession(value);
				return true;
			}
			session = null;
			return false;
		}

		public bool TryGetSession(string sessionId, out ArenaSession session)
		{
			if (!string.IsNullOrWhiteSpace(sessionId) && _sessionsById.TryGetValue(sessionId, out var value))
			{
				session = CloneSession(value);
				return true;
			}
			session = null;
			return false;
		}

		private void TryCallNext(string arenaId, DateTime now)
		{
			if (string.IsNullOrWhiteSpace(arenaId) || _activeByArena.ContainsKey(arenaId))
			{
				return;
			}
			QueueEntry queueEntry;
			ChallengePlan value;
			while (true)
			{
				int num = _queue.FindIndex((QueueEntry entry) => string.Equals(entry.Request.ArenaId, arenaId, StringComparison.OrdinalIgnoreCase));
				if (num < 0)
				{
					return;
				}
				queueEntry = _queue[num];
				_queue.RemoveAt(num);
				try
				{
					if (!_recoveredPlansByRequestId.TryGetValue(queueEntry.Request.RequestId, out value))
					{
						value = _planFactory(CloneRequest(queueEntry.Request));
					}
					ValidatePlan(value, queueEntry.Request);
					value = ClonePlan(value);
				}
				catch (Exception ex)
				{
					Emit(ArenaEffectType.SetArenaRole, arenaId, null, queueEntry.Request.PlayerId, null, ArenaRole.Spectator.ToString());
					Emit(ArenaEffectType.SendLocalMessage, arenaId, null, queueEntry.Request.PlayerId, null, "ArenaGuard rejected the challenge plan: " + ex.Message);
					Emit(ArenaEffectType.PersistState, arenaId, null, queueEntry.Request.PlayerId, null, "Invalid challenge request removed.");
					continue;
				}
				break;
			}
			ArenaSession arenaSession = new ArenaSession
			{
				SessionId = NewId(),
				ArenaId = queueEntry.Request.ArenaId,
				Request = CloneRequest(queueEntry.Request),
				Plan = value,
				Phase = SessionPhase.Called,
				Outcome = SessionOutcome.None,
				EncounterIndex = 0,
				LivingArenaEnemyCount = 0,
				SpawnedEnemyIds = new List<string>(),
				ResourceSnapshot = null,
				PhaseStartedUtc = now,
				PhaseDeadlineUtc = now.Add(_options.QueueAcceptanceTimeout),
				SessionStartedUtc = DateTime.MinValue,
				ElapsedMilliseconds = 0L
			};
			_activeByArena[arenaId] = arenaSession;
			_sessionsById[arenaSession.SessionId] = arenaSession;
			_originGateBySessionId[arenaSession.SessionId] = queueEntry.OriginGateId ?? string.Empty;
			Emit(ArenaEffectType.CallQueuedPlayer, arenaSession, null, "Your arena turn is ready. Accept within " + (int)_options.QueueAcceptanceTimeout.TotalSeconds + " seconds.");
			Emit(ArenaEffectType.PersistState, arenaSession, null, "Queued player called.");
		}

		private void HandleCallTimeout(ArenaSession session, DateTime now)
		{
			if (IsActive(session) && session.Phase == SessionPhase.Called)
			{
				session.Outcome = SessionOutcome.StartTimeout;
				session.Phase = SessionPhase.Closed;
				session.PhaseStartedUtc = now;
				session.PhaseDeadlineUtc = DateTime.MinValue;
				_activeByArena.Remove(session.ArenaId);
				_originGateBySessionId.TryGetValue(session.SessionId, out var value);
				_originGateBySessionId.Remove(session.SessionId);
				_queue.Add(new QueueEntry
				{
					Request = CloneRequest(session.Request),
					OriginGateId = (value ?? string.Empty),
					QueueSequence = _nextQueueSequence++,
					EnqueuedUtc = now
				});
				Emit(ArenaEffectType.SetArenaRole, session, null, ArenaRole.Queued.ToString());
				Emit(ArenaEffectType.SendLocalMessage, session, null, "Queue acceptance expired; you were moved to the back of the queue.");
				Emit(ArenaEffectType.PersistState, session, null, "Queue acceptance timed out.");
				TryCallNext(session.ArenaId, now);
			}
		}

		private void HandleStagingTimeout(ArenaSession session, DateTime now)
		{
			if (IsActive(session) && session.Phase == SessionPhase.Staging)
			{
				session.Outcome = SessionOutcome.StartTimeout;
				session.Phase = SessionPhase.Closed;
				session.PhaseStartedUtc = now;
				session.PhaseDeadlineUtc = DateTime.MinValue;
				_activeByArena.Remove(session.ArenaId);
				_originGateBySessionId.Remove(session.SessionId);
				_recoveredPlansByRequestId.Remove(session.Request.RequestId);
				if (session.ResourceSnapshot != null)
				{
					Emit(ArenaEffectType.RestorePlayerState, session, null, "Restore the timed-out arena food loadout.");
				}
				Emit(ArenaEffectType.PersistState, session, null, "Staging start timed out.");
				Emit(ArenaEffectType.MoveToSpectatorArea, session, null, "Return timed-out player to spectators.");
				Emit(ArenaEffectType.SetArenaRole, session, null, ArenaRole.Spectator.ToString());
				Emit(ArenaEffectType.SendLocalMessage, session, null, "Challenge start timed out.");
				TryCallNext(session.ArenaId, now);
			}
		}

		private void BeginEncounter(ArenaSession session, DateTime now)
		{
			if (IsActive(session) && (session.Phase == SessionPhase.Countdown || session.Phase == SessionPhase.Intermission))
			{
				session.Phase = SessionPhase.Fighting;
				session.PhaseStartedUtc = now;
				session.PhaseDeadlineUtc = DateTime.MinValue;
				session.LivingArenaEnemyCount = CurrentEncounter(session).Quantity;
				Emit(ArenaEffectType.PersistState, session, CurrentEncounter(session), "Encounter ready to spawn.");
				Emit(ArenaEffectType.SpawnEncounter, session, CurrentEncounter(session), "Spawn current encounter.");
			}
		}

		private void StartCountdown(ArenaSession session, SessionPhase phase, DateTime now)
		{
			session.Phase = phase;
			session.PhaseStartedUtc = now;
			session.PhaseDeadlineUtc = now.AddSeconds(CurrentEncounter(session).PreparationSeconds);
		}

		private void EndRun(ArenaSession session, SessionOutcome outcome, SessionPhase terminalPhase, DateTime now, string announcement, bool recordResult)
		{
			if (IsActive(session))
			{
				UpdateElapsed(session, now);
				session.Outcome = outcome;
				session.Phase = terminalPhase;
				session.PhaseStartedUtc = now;
				session.PhaseDeadlineUtc = DateTime.MinValue;
				_boundaryDeadlines.Remove(session.Request.PlayerId);
				if (recordResult)
				{
					Emit(ArenaEffectType.UpdateLeaderboard, session, CurrentEncounterOrNull(session), "Record challenge result.");
				}
				EmitAnnouncement(session, announcement);
				FinalizeTerminalSession(session, now, wasVictory: false);
			}
		}

		private void FinalizeTerminalSession(ArenaSession session, DateTime now, bool wasVictory)
		{
			if (IsActive(session))
			{
				UpdateElapsed(session, now);
				session.PhaseDeadlineUtc = DateTime.MinValue;
				_activeByArena.Remove(session.ArenaId);
				_boundaryDeadlines.Remove(session.Request.PlayerId);
				_originGateBySessionId.Remove(session.SessionId);
				_recoveredPlansByRequestId.Remove(session.Request.RequestId);
				Emit(ArenaEffectType.DespawnSessionEnemies, session, CurrentEncounterOrNull(session), "Remove all arena enemies.");
				if (session.ResourceSnapshot != null)
				{
					Emit(ArenaEffectType.RestorePlayerState, session, CurrentEncounterOrNull(session), "Restore food, ammunition, and allowed consumables.");
				}
				Emit(ArenaEffectType.MoveToStaging, session, CurrentEncounterOrNull(session), wasVictory ? "Return victor to staging after results." : "Return combatant to staging.");
				Emit(ArenaEffectType.SetArenaRole, session, null, ArenaRole.Spectator.ToString());
				Emit(ArenaEffectType.PersistState, session, CurrentEncounterOrNull(session), "Finalize terminal session after restoration is durable.");
				TryCallNext(session.ArenaId, now);
			}
		}

		private void EmitAnnouncement(ArenaSession session, string action)
		{
			string message = (string.IsNullOrWhiteSpace(session.Request.PlayerName) ? "A combatant" : session.Request.PlayerName.Trim()) + " " + action;
			ArenaEffectType type = ((session.Plan.Mode == ChallengeMode.CustomEncounter) ? ArenaEffectType.SendLocalMessage : ArenaEffectType.SendGlobalMessage);
			Emit(type, session, CurrentEncounterOrNull(session), message);
		}

		private void Emit(ArenaEffectType type, ArenaSession session, EncounterDefinition encounter, string message)
		{
			Emit(type, session.ArenaId, session.SessionId, session.Request.PlayerId, encounter, message);
		}

		private void Emit(ArenaEffectType type, string arenaId, string sessionId, long playerId, EncounterDefinition encounter, string message)
		{
			_effects.Add(new ArenaEffect
			{
				Type = type,
				ArenaId = arenaId,
				SessionId = sessionId,
				PlayerId = playerId,
				Encounter = CloneEncounter(encounter),
				Message = message
			});
		}

		private ArenaSession FindActiveByPlayer(long playerId)
		{
			return _activeByArena.Values.FirstOrDefault((ArenaSession session) => session.Request.PlayerId == playerId);
		}

		private bool IsActive(ArenaSession session)
		{
			if (session != null && _activeByArena.TryGetValue(session.ArenaId, out var value))
			{
				return value == session;
			}
			return false;
		}

		private bool ContainsPlayer(long playerId)
		{
			if (!_queue.Any((QueueEntry entry) => entry.Request.PlayerId == playerId))
			{
				return FindActiveByPlayer(playerId) != null;
			}
			return true;
		}

		private bool ContainsRequest(string requestId)
		{
			if (!_queue.Any((QueueEntry entry) => string.Equals(entry.Request.RequestId, requestId, StringComparison.OrdinalIgnoreCase)))
			{
				return _activeByArena.Values.Any((ArenaSession session) => string.Equals(session.Request.RequestId, requestId, StringComparison.OrdinalIgnoreCase));
			}
			return true;
		}

		private DateTime Now()
		{
			DateTime result = _utcNow();
			if (result.Kind != DateTimeKind.Local)
			{
				return result;
			}
			return result.ToUniversalTime();
		}

		private static bool IsChallengeInProgress(ArenaSession session)
		{
			if (session.Phase != SessionPhase.Countdown && session.Phase != SessionPhase.Fighting)
			{
				return session.Phase == SessionPhase.Intermission;
			}
			return true;
		}

		private static bool IsRecoverable(ArenaSession session)
		{
			if (session != null && !string.IsNullOrWhiteSpace(session.SessionId) && !string.IsNullOrWhiteSpace(session.ArenaId) && session.Request != null && !string.IsNullOrWhiteSpace(session.Request.RequestId) && session.Request.PlayerId != 0L && session.Plan != null && session.Plan.Encounters != null && session.Plan.Encounters.Count > 0)
			{
				if (session.ResourceSnapshot == null && session.Phase != SessionPhase.Called)
				{
					return session.Phase == SessionPhase.Staging;
				}
				return true;
			}
			return false;
		}

		private static void ValidateQueueEntry(QueueEntry entry)
		{
			if (entry == null)
			{
				throw new ArgumentNullException("entry");
			}
			if (entry.Request == null)
			{
				throw new ArgumentException("Queue entry requires a challenge request.", "entry");
			}
			if (string.IsNullOrWhiteSpace(entry.Request.RequestId) || string.IsNullOrWhiteSpace(entry.Request.ArenaId) || entry.Request.PlayerId == 0L)
			{
				throw new ArgumentException("Queue request requires request ID, arena ID, and player ID.", "entry");
			}
		}

		private static void ValidatePlan(ChallengePlan plan, ChallengeRequest request)
		{
			if (plan == null || string.IsNullOrWhiteSpace(plan.PlanId) || plan.Encounters == null || plan.Encounters.Count == 0)
			{
				throw new InvalidOperationException("Challenge planning returned an empty or malformed plan.");
			}
			if (plan.Mode != request.Mode || plan.CapMode != request.CapMode || (request.CapMode == ProgressionCapMode.Biome && plan.HighestBiome != request.SelectedBiome))
			{
				throw new InvalidOperationException("Challenge plan does not match its request.");
			}
			for (int i = 0; i < plan.Encounters.Count; i++)
			{
				EncounterDefinition encounterDefinition = plan.Encounters[i];
				if (encounterDefinition == null || encounterDefinition.Sequence != i || string.IsNullOrWhiteSpace(encounterDefinition.CreatureKey) || encounterDefinition.Quantity < 1 || encounterDefinition.PreparationSeconds < 0)
				{
					throw new InvalidOperationException("Challenge plan contains a malformed encounter.");
				}
			}
		}

		private static void ValidateOptions(ArenaSessionOptions options)
		{
			if (options.QueueAcceptanceTimeout <= TimeSpan.Zero || options.StagingTimeout <= TimeSpan.Zero || options.BoundaryGracePeriod <= TimeSpan.Zero || options.VictoryDisplayDuration < TimeSpan.Zero)
			{
				throw new ArgumentOutOfRangeException("options", "Session timeouts must be positive (victory display may be zero).");
			}
		}

		private static EncounterDefinition CurrentEncounter(ArenaSession session)
		{
			return session.Plan.Encounters[session.EncounterIndex];
		}

		private static EncounterDefinition CurrentEncounterOrNull(ArenaSession session)
		{
			if (session == null || session.Plan == null || session.Plan.Encounters == null || session.EncounterIndex < 0 || session.EncounterIndex >= session.Plan.Encounters.Count)
			{
				return null;
			}
			return CurrentEncounter(session);
		}

		private static void UpdateElapsed(ArenaSession session, DateTime now)
		{
			if (!(session.SessionStartedUtc == DateTime.MinValue) && session.Phase == SessionPhase.Fighting)
			{
				if (session.PhaseStartedUtc == DateTime.MinValue || now <= session.PhaseStartedUtc)
				{
					session.PhaseStartedUtc = now;
					return;
				}
				long num = (long)(now - session.PhaseStartedUtc).TotalMilliseconds;
				session.ElapsedMilliseconds = Math.Max(0L, session.ElapsedMilliseconds + num);
				session.PhaseStartedUtc = now;
			}
		}

		private static string CountdownMessage(ArenaSession session)
		{
			return "Encounter " + (session.EncounterIndex + 1) + " of " + session.Plan.Encounters.Count + " begins in " + CurrentEncounter(session).PreparationSeconds + " seconds.";
		}

		private static string DescribeMode(ChallengeMode mode)
		{
			return mode switch
			{
				ChallengeMode.BiomeLadder => "the biome ladder", 
				ChallengeMode.StarLadder => "the star ladder", 
				ChallengeMode.CustomEncounter => "a custom encounter", 
				_ => "an arena challenge", 
			};
		}

		private static string NewId()
		{
			return Guid.NewGuid().ToString("N").ToLowerInvariant();
		}

		private static ArenaEffect CloneEffect(ArenaEffect effect)
		{
			return new ArenaEffect
			{
				Type = effect.Type,
				ArenaId = effect.ArenaId,
				SessionId = effect.SessionId,
				PlayerId = effect.PlayerId,
				Encounter = CloneEncounter(effect.Encounter),
				Message = effect.Message
			};
		}

		private static QueueEntry CloneQueueEntry(QueueEntry entry)
		{
			return new QueueEntry
			{
				Request = CloneRequest(entry.Request),
				OriginGateId = entry.OriginGateId,
				QueueSequence = entry.QueueSequence,
				EnqueuedUtc = entry.EnqueuedUtc
			};
		}

		private static ChallengeRequest CloneRequest(ChallengeRequest request)
		{
			if (request == null)
			{
				return null;
			}
			return new ChallengeRequest
			{
				RequestId = request.RequestId,
				ArenaId = request.ArenaId,
				PlayerId = request.PlayerId,
				PlayerName = request.PlayerName,
				Mode = request.Mode,
				CapMode = request.CapMode,
				SelectedBiome = request.SelectedBiome,
				CustomSelection = ((request.CustomSelection == null) ? null : new CustomEncounterSelection
				{
					CreatureKey = request.CustomSelection.CreatureKey,
					Stars = request.CustomSelection.Stars,
					Quantity = request.CustomSelection.Quantity
				}),
				RequestedUtc = request.RequestedUtc
			};
		}

		private static ChallengePlan ClonePlan(ChallengePlan plan)
		{
			if (plan == null)
			{
				return null;
			}
			return new ChallengePlan
			{
				PlanId = plan.PlanId,
				Mode = plan.Mode,
				CapMode = plan.CapMode,
				HighestBiome = plan.HighestBiome,
				RosterRevision = plan.RosterRevision,
				Encounters = ((plan.Encounters == null) ? null : plan.Encounters.Select(CloneEncounter).ToList())
			};
		}

		private static EncounterDefinition CloneEncounter(EncounterDefinition encounter)
		{
			if (encounter == null)
			{
				return null;
			}
			return new EncounterDefinition
			{
				Sequence = encounter.Sequence,
				CreatureKey = encounter.CreatureKey,
				Biome = encounter.Biome,
				Stars = encounter.Stars,
				Quantity = encounter.Quantity,
				IsMiniboss = encounter.IsMiniboss,
				PreparationSeconds = encounter.PreparationSeconds
			};
		}

		private static PlayerResourceSnapshot CloneResourceSnapshot(PlayerResourceSnapshot snapshot)
		{
			if (snapshot == null)
			{
				return null;
			}
			return new PlayerResourceSnapshot
			{
				PlayerId = snapshot.PlayerId,
				Foods = ((snapshot.Foods == null) ? null : snapshot.Foods.Select((FoodStateSnapshot food) => new FoodStateSnapshot
				{
					ItemPrefabName = food.ItemPrefabName,
					RemainingSeconds = food.RemainingSeconds,
					Health = food.Health,
					Stamina = food.Stamina,
					Eitr = food.Eitr
				}).ToList()),
				RestedRemainingSeconds = snapshot.RestedRemainingSeconds,
				ArenaFoodPrefabNames = ((snapshot.ArenaFoodPrefabNames == null) ? new List<string>() : new List<string>(snapshot.ArenaFoodPrefabNames)),
				AllowedConsumableCounts = ((snapshot.AllowedConsumableCounts == null) ? null : new Dictionary<string, int>(snapshot.AllowedConsumableCounts, StringComparer.Ordinal)),
				AmmunitionCounts = ((snapshot.AmmunitionCounts == null) ? null : new Dictionary<string, int>(snapshot.AmmunitionCounts, StringComparer.Ordinal)),
				EquipmentDurabilityBySlot = ((snapshot.EquipmentDurabilityBySlot == null) ? null : new Dictionary<string, float>(snapshot.EquipmentDurabilityBySlot, StringComparer.Ordinal)),
				CapturedUtc = snapshot.CapturedUtc
			};
		}

		private static ArenaSession CloneSession(ArenaSession session)
		{
			if (session == null)
			{
				return null;
			}
			return new ArenaSession
			{
				SessionId = session.SessionId,
				ArenaId = session.ArenaId,
				Request = CloneRequest(session.Request),
				Plan = ClonePlan(session.Plan),
				Phase = session.Phase,
				Outcome = session.Outcome,
				EncounterIndex = session.EncounterIndex,
				LivingArenaEnemyCount = session.LivingArenaEnemyCount,
				SpawnedEnemyIds = ((session.SpawnedEnemyIds == null) ? new List<string>() : new List<string>(session.SpawnedEnemyIds)),
				ResourceSnapshot = CloneResourceSnapshot(session.ResourceSnapshot),
				PhaseStartedUtc = session.PhaseStartedUtc,
				PhaseDeadlineUtc = session.PhaseDeadlineUtc,
				SessionStartedUtc = session.SessionStartedUtc,
				ElapsedMilliseconds = session.ElapsedMilliseconds
			};
		}
	}
	public static class ArenaStartPolicy
	{
		public static bool ShouldTeleportToCombatStart(SessionPhase phase, bool resourceSnapshotReady)
		{
			return phase == SessionPhase.Staging && resourceSnapshotReady;
		}

		public static bool ShouldBeginCountdown(SessionPhase phase, bool resourceSnapshotReady, bool combatStartArrivalConfirmed)
		{
			return ShouldTeleportToCombatStart(phase, resourceSnapshotReady) && combatStartArrivalConfirmed;
		}
	}
}
namespace ArenaGuard.Runtime
{
	internal sealed class ArenaAdminCommand : ConsoleCommand
	{
		public override string Name => "arenaguard";

		public override string Help => "SkaldHall recovery: arenaguard status [arena] | abort <arena|all> | clearqueue <arena|all>";

		public override bool IsCheat => false;

		public override bool IsNetwork => false;

		public override bool OnlyServer => false;

		public override List<string> CommandOptionList()
		{
			return new List<string> { "status", "abort", "clearqueue" };
		}

		public override void Run(string[] args, Terminal context)
		{
			if ((!((Object)(object)ZNet.instance != (Object)null) || !ZNet.instance.IsServer() || !((Object)(object)Player.m_localPlayer == (Object)null)) && !ArenaWorldObjects.IsLocalAdmin())
			{
				if (context != null)
				{
					context.AddString("SkaldHall: only an authenticated server administrator may use this command.");
				}
				return;
			}
			if (args == null || args.Length == 0)
			{
				if (context != null)
				{
					context.AddString("Usage: " + ((ConsoleCommand)this).Help);
				}
				return;
			}
			string operation = (args[0] ?? string.Empty).Trim().ToLowerInvariant();
			string target = ((args.Length <= 1) ? string.Empty : string.Join(" ", args.Skip(1).ToArray()).Trim());
			if (!ArenaServerRuntime.RequestAdminCommand(operation, target, out var response))
			{
				if (context != null)
				{
					context.AddString("SkaldHall: " + response);
				}
			}
			else if (context != null)
			{
				context.AddString("SkaldHall: " + response);
			}
		}
	}
	[HarmonyPatch(typeof(Game), "OnDestroy")]
	internal static class ArenaWorldShutdownPatch
	{
		[HarmonyPrefix]
		private static void Prefix()
		{
			ArenaServerRuntime.PrepareForWorldShutdown();
		}
	}
	internal static class ArenaServerRuntime
	{
		private sealed class ArenaEnemyHandle
		{
			internal string EnemyId;

			internal string ArenaId;

			internal string SessionId;

			internal Character Character;

			internal Vector3 SpawnPosition;

			internal int SpawnMarkerIndex;
		}

		private sealed class PendingRestore
		{
			internal long PlayerId;

			internal PlayerResourceSnapshot Snapshot;

			internal SessionOutcome Outcome;

			internal ArenaSession Session;

			internal DateTime NextAttemptUtc;
		}

		private sealed class ClientPreparationState
		{
			internal PlayerResourceSnapshot Snapshot;

			internal DateTime SubmittedUtc;

			internal int SubmissionAttempts;

			internal bool Accepted;
		}

		private sealed class CombatBoundaryState
		{
			internal string ArenaId;

			internal DateTime OutsideSinceUtc;

			internal DateTime NextPopupUtc;
		}

		internal const string EnemyArenaZdoKey = "arenaguard.arena_id";

		internal const string EnemySessionZdoKey = "arenaguard.session_id";

		internal const string EnemyIdZdoKey = "arenaguard.enemy_id";

		private static readonly MethodInfo MonsterAiWakeupMethod = AccessTools.Method(typeof(MonsterAI), "Wakeup", Type.EmptyTypes, (Type[])null);

		private static readonly MethodInfo MonsterAiSetTargetMethod = AccessTools.Method(typeof(MonsterAI), "SetTarget", new Type[1] { typeof(Character) }, (Type[])null);

		private static readonly MethodInfo PlayerUpdateFoodMethod = AccessTools.Method(typeof(Player), "UpdateFood", new Type[2]
		{
			typeof(float),
			typeof(bool)
		}, (Type[])null);

		private static readonly FieldInfo TerminalCheatField = AccessTools.Field(typeof(Terminal), "m_cheat");

		private static readonly Dictionary<long, ArenaRole> Roles = new Dictionary<long, ArenaRole>();

		private static readonly Dictionary<string, ArenaEnemyHandle> Enemies = new Dictionary<string, ArenaEnemyHandle>(StringComparer.Ordinal);

		private static readonly Dictionary<string, int> LastSpawnMarkerBySessionId = new Dictionary<string, int>(StringComparer.Ordinal);

		private static readonly Random SpawnRandom = new Random();

		private static readonly Dictionary<long, PlayerResourceSnapshot> ResourceSnapshots = new Dictionary<long, PlayerResourceSnapshot>();

		private static readonly Dictionary<long, PendingRestore> PendingRestores = new Dictionary<long, PendingRestore>();

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

		private static readonly Dictionary<string, ClientPreparationState> ClientPreparations = new Dictionary<string, ClientPreparationState>(StringComparer.Ordinal);

		private static readonly Dictionary<string, string> ClientQueuePromptSessions = new Dictionary<string, string>(StringComparer.Ordinal);

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

		private static readonly Dictionary<string, ArenaClientSnapshot> ClientArenaSnapshots = new Dictionary<string, ArenaClientSnapshot>(StringComparer.Ordinal);

		private static readonly Dictionary<string, DateTime> ClientCombatStartArrivalRetryUtc = new Dictionary<string, DateTime>(StringComparer.Ordinal);

		private static readonly List<string> StaleClientCombatStartArrivalArenaIds = new List<string>();

		private static readonly Dictionary<long, DateTime> CombatStartMoveRetryUtc = new Dictionary<long, DateTime>();

		private static readonly Dictionary<long, CombatBoundaryState> CombatBoundaryStates = new Dictionary<long, CombatBoundaryState>();

		private static readonly HashSet<long> ActiveCombatantIds = new HashSet<long>();

		private static readonly HashSet<long> AwaitingCombatStartIds = new HashSet<long>();

		private static readonly List<long> StaleCombatantIds = new List<long>();

		private static readonly List<Character> ProtectedWildlifeCharacters = new List<Character>();

		private static readonly List<RandomFlyingBird> ProtectedWildlifeBirds = new List<RandomFlyingBird>();

		private static readonly TimeSpan CombatBoundaryPopupInterval = TimeSpan.FromSeconds(1.0);

		private const float CombatStartArrivalRadius = 4f;

		private static bool _initialized;

		private static long _loadedWorldUid;

		private static DateTime _nextCollisionRefreshUtc;

		private static DateTime _nextStateBroadcastUtc;

		private static DateTime _nextProtectedWildlifeSweepUtc;

		private static float _nextClientCombatStartArrivalCheckTime;

		private static bool _clientAdminsMayModifyTerrain;

		private static bool _clientAdminsMayBuild;

		private static bool _clientAdminsMayPickupDroppedItems;

		private static ChallengeCatalog _catalog;

		private static ArenaSessionEngine _engine;

		private static bool AdminsMayModifyTerrain()
		{
			if (!((Object)(object)ZNet.instance != (Object)null) || !ZNet.instance.IsServer())
			{
				return _clientAdminsMayModifyTerrain;
			}
			return ArenaConfig.AllowAdminTerrainEditing?.Value ?? false;
		}

		private static bool AdminsMayBuild()
		{
			if (!((Object)(object)ZNet.instance != (Object)null) || !ZNet.instance.IsServer())
			{
				return _clientAdminsMayBuild;
			}
			return ArenaConfig.AllowAdminBuilding?.Value ?? false;
		}

		private static bool AdminsMayPickupDroppedItems()
		{
			if (!((Object)(object)ZNet.instance != (Object)null) || !ZNet.instance.IsServer())
			{
				return _clientAdminsMayPickupDroppedItems;
			}
			return ArenaConfig.AllowAdminDroppedItemPickup?.Value ?? false;
		}

		private static bool AreLocalDevcommandsEnabled()
		{
			try
			{
				bool flag = default(bool);
				int num;
				if (TerminalCheatField != null)
				{
					object value = TerminalCheatField.GetValue(null);
					if (value is bool)
					{
						flag = (bool)value;
						num = 1;
					}
					else
					{
						num = 0;
					}
				}
				else
				{
					num = 0;
				}
				return (byte)((uint)num & (flag ? 1u : 0u)) != 0;
			}
			catch (Exception ex)
			{
				Plugin.Debug("Could not read the local devcommands state: " + ex.Message);
				return false;
			}
		}

		private static bool ResolveAdminPermission(ArenaAdminPermissionKind permission)
		{
			return permission switch
			{
				ArenaAdminPermissionKind.Terrain => AdminsMayModifyTerrain(), 
				ArenaAdminPermissionKind.Building => AdminsMayBuild(), 
				ArenaAdminPermissionKind.DroppedItemPickup => AdminsMayPickupDroppedItems(), 
				_ => false, 
			};
		}

		internal static bool RequestAdminCommand(string operation, string target, out string response)
		{
			//IL_013a: Unknown result type (might be due to invalid IL or missing references)
			ArenaAdminMutationKind arenaAdminMutationKind;
			switch ((operation ?? string.Empty).Trim().ToLowerInvariant())
			{
			case "status":
				arenaAdminMutationKind = ArenaAdminMutationKind.RequestAdminStatus;
				break;
			case "abort":
				arenaAdminMutationKind = (string.Equals(target?.Trim(), "all", StringComparison.OrdinalIgnoreCase) ? ArenaAdminMutationKind.AbortAllArenas : ArenaAdminMutationKind.AbortArena);
				break;
			case "clearqueue":
				arenaAdminMutationKind = ArenaAdminMutationKind.ClearArenaQueue;
				break;
			default:
				response = "unknown operation. Use status, abort, or clearqueue.";
				return false;
			}
			if ((arenaAdminMutationKind == ArenaAdminMutationKind.AbortArena || arenaAdminMutationKind == ArenaAdminMutationKind.ClearArenaQueue) && string.IsNullOrWhiteSpace(target))
			{
				response = "an arena ID/name or 'all' is required.";
				return false;
			}
			ArenaAdminMutation mutation = new ArenaAdminMutation
			{
				Kind = arenaAdminMutationKind,
				TargetId = (target?.Trim() ?? string.Empty)
			};
			if ((Object)(object)ZNet.instance != (Object)null && ZNet.instance.IsServer())
			{
				Player localPlayer = Player.m_localPlayer;
				ArenaRpcResult arenaRpcResult = OnAdminMutationRequested(new ArenaRequestContext
				{
					PlayerId = ((localPlayer != null) ? localPlayer.GetPlayerID() : 0),
					PlayerName = (((localPlayer != null) ? localPlayer.GetPlayerName() : null) ?? "Dedicated server console"),
					IsAdmin = ((Object)(object)localPlayer == (Object)null || ZNet.instance.LocalPlayerIsAdminOrHost()),
					Position = (((Object)(object)localPlayer == (Object)null) ? default(PositionData) : ToPositionData(((Component)localPlayer).transform.position))
				}, mutation);
				response = arenaRpcResult.Message;
				return arenaRpcResult.Success;
			}
			ArenaRpc.RequestAdminMutation(mutation);
			response = "request sent; the authenticated server result will appear on screen.";
			return true;
		}

		internal static void Initialize()
		{
			if (!_initialized)
			{
				_catalog = new ChallengeCatalog();
				_engine = new ArenaSessionEngine((ChallengeRequest request) => _catalog.BuildPlan(request, GetWorldUnlockedBiome()), () => DateTime.UtcNow, new ArenaSessionOptions
				{
					QueueAcceptanceTimeout = TimeSpan.FromSeconds(Math.Max(1, ArenaConfig.QueueAcceptSeconds.Value)),
					StagingTimeout = TimeSpan.FromSeconds(Math.Max(1, ArenaConfig.StagingTimeoutSeconds.Value)),
					BoundaryGracePeriod = TimeSpan.FromSeconds(Math.Max(1, ArenaConfig.BoundaryGraceSeconds.Value)),
					VictoryDisplayDuration = TimeSpan.FromSeconds(Math.Max(0, ArenaConfig.ResultsSeconds.Value))
				});
				ArenaRuleContext.IsProtectedPoint = (Vector3 position) => ArenaRegistry.FindProtectedArena(ToPositionData(position)) != null;
				ArenaRuleContext.IsActiveProtectedPoint = delegate(Vector3 position)
				{
					//IL_0000: Unknown result type (might be due to invalid IL or missing references)
					ArenaDefinition arenaDefinition = ArenaRegistry.FindProtectedArena(ToPositionData(position));
					ArenaSession session;
					return arenaDefinition != null && ArenaRegistry.TryGetActiveSession(arenaDefinition.ArenaId, out session);
				};
				ArenaRuleContext.IsAdministrator = IsAdministrator;
				ArenaRuleContext.AdminsMayModifyTerrain = AdminsMayModifyTerrain;
				ArenaRuleContext.AdminsMayBuild = AdminsMayBuild;
				ArenaRuleContext.AdminsMayPickupDroppedItems = AdminsMayPickupDroppedItems;
				ArenaRuleContext.AreLocalDevcommandsEnabled = AreLocalDevcommandsEnabled;
				ArenaRuleContext.ResolveRole = ResolveRole;
				ArenaRuleContext.ResolveEnemyArenaId = ResolveEnemyArenaId;
				ArenaRuleContext.ResolveCombatant = ResolveCombatant;
				ArenaRuleContext.ReportLethalDamage = ReportLethalDamage;
				ArenaRuleContext.ReportArenaEnemyDeath = ReportArenaEnemyDeath;
				ArenaRuleContext.RegisterArenaSummon = RegisterArenaSummon;
				ArenaWorldObjects.LocalAdminResolver = IsLocalAdministrator;
				ArenaWorldObjects.ArenaAtPositionResolver = (Vector3 position) => ArenaRegistry.FindProtectedArena(ToPositionData(position))?.ArenaId;
				ArenaWorldObjects.ArenaDefinitionResolver = (string arenaId) => (!ArenaRegistry.TryGetArena(arenaId, out var definition)) ? null : definition;
				ArenaWorldObjects.PlacementRequested = RequestPlacementMutation;
				ArenaWorldObjects.CoreRemovalRequested = RequestCoreRemoval;
				ArenaWorldObjects.CoreActivated = RequestStaleCoreCleanup;
				ArenaWorldObjects.AdminMarkerRequested = RequestMarkerMutation;
				ArenaWorldObjects.AdminMarkerRemovalRequested = RequestMarkerRemoval;
				ArenaTeleporters.GateTravelRequested = (Player _, string gateId, bool returning) => ArenaRpc.RequestGateTravel(gateId, returning);
				ArenaTeleporters.GateConfigurationRequested = RequestGateConfiguration;
				ArenaUi.ChallengeRequested = ArenaRpc.RequestChallenge;
				ArenaUi.QueueAccepted = ArenaRpc.AcceptQueueCall;
				ArenaUi.ForfeitRequested = ArenaRpc.RequestForfeit;
				ArenaUi.LeaderboardRequested = delegate(string _, LeaderboardKey key)
				{
					ArenaRpc.RequestLeaderboard(key);
				};
				ArenaUi.AdminMutationRequested = RequestUiAdminMutation;
				ArenaUi.AdminPermissionResolver = ResolveAdminPermission;
				ArenaUi.CreatureListResolver = () => _catalog.GetRoster();
				ArenaUi.FoodPreparationConfirmed = ConfirmLocalFoodPreparation;
				ArenaUi.FoodPreparationCancelled = ArenaRpc.RequestForfeit;
				ArenaRpc.Configure(new ArenaRpcCallbacks
				{
					ChallengeRequested = OnChallengeRequested,
					QueueCallAccepted = OnQueueCallAccepted,
					ForfeitRequested = OnForfeitRequested,
					LethalDamageReported = OnLethalDamageReported,
					CombatStartArrived = OnCombatStartArrived,
					AdminMutationRequested = OnAdminMutationRequested,
					GateTravelAuthorizing = OnGateTravelAuthorizing,
					GateTravelCompleted = OnGateTravelCompleted,
					ClientGateTravelAuthorized = OnClientGateTravelAuthorized,
					ResourceSnapshotReceived = OnResourceSnapshotReceived,
					ClientResourceRestoreRequested = OnClientResourceRestoreRequested,
					ResourceRestoreCompleted = OnResourceRestoreCompleted,
					ClientMoveRequested = OnClientMoveRequested,
					SnapshotRequested = BuildClientSnapshot,
					LeaderboardRequested = GetCurrentRosterLeaderboard,
					ClientSnapshotReceived = OnClientSnapshotReceived,
					ClientArenaRemoved = OnClientArenaRemoved,
					ClientGateConfigurationReceived = delegate(ArenaGateDefinition gate)
					{
						ArenaTeleporters.ApplyGateConfiguration(gate.GateId, gate.ArenaId, gate.DisplayName, gate.IsFallbackEntrance);
					},
					ClientLeaderboardReceived = OnClientLeaderboardReceived,
					ClientActionResultReceived = OnClientActionResultReceived,
					ServerPeerConnected = delegate
					{
						BroadcastAllArenaStates();
					}
				});
				_initialized = true;
			}
		}

		private static void LoadWorld(long worldUid)
		{
			if (worldUid == 0L)
			{
				return;
			}
			if (_loadedWorldUid != 0L && (Object)(object)ZNet.instance != (Object)null && ZNet.instance.IsServer())
			{
				SaveWorldState();
			}
			_loadedWorldUid = worldUid;
			Roles.Clear();
			Enemies.Clear();
			LastSpawnMarkerBySessionId.Clear();
			ResourceSnapshots.Clear();
			PendingRestores.Clear();
			ClientFoodPrompts.Clear();
			ClientPreparations.Clear();
			ClientQueuePromptSessions.Clear();
			ClientRestoredSnapshots.Clear();
			ClientArenaSnapshots.Clear();
			_clientAdminsMayModifyTerrain = false;
			_clientAdminsMayBuild = false;
			_clientAdminsMayPickupDroppedItems = false;
			ClientCombatStartArrivalRetryUtc.Clear();
			StaleClientCombatStartArrivalArenaIds.Clear();
			CombatStartMoveRetryUtc.Clear();
			CombatBoundaryStates.Clear();
			ActiveCombatantIds.Clear();
			AwaitingCombatStartIds.Clear();
			StaleCombatantIds.Clear();
			_nextClientCombatStartArrivalCheckTime = 0f;
			if (!ZNet.instance.IsServer())
			{
				ArenaRegistry.Clear();
				Plugin.Debug("Prepared client arena state for world " + worldUid + ".");
				return;
			}
			PersistedWorldState state = ArenaStore.Load(worldUid);
			ArenaRegistry.Replace(state);
			_engine.RecoverAfterRestart(state);
			SyncRegistryFromEngine();
			ProcessEngineEffects();
			SaveWorldState();
			BroadcastAllArenaStates();
			ManualLogSource log = Plugin.Log;
			if (log != null)
			{
				log.LogInfo((object)("SkaldHall is ready for world " + worldUid + "."));
			}
		}

		private static ArenaRpcResult OnChallengeRequested(ArenaRequestContext context, ChallengeRequest request)
		{
			try
			{
				if (_initialized && _engine != null && ArenaRegistry.TryGetArena(request.ArenaId, out var definition) && definition.Enabled)
				{
					ArenaMarkerSet markers = definition.Markers;
					if (markers != null && markers.EnemySpawnPositions?.Count == 4)
					{
						if (!ArenaRegistry.IsWithinCombatRadius(definition, definition.Markers.CombatantStartPosition))
						{
							return ArenaRpcResult.Rejected("Combat Start is outside the combat radius. An admin must move it inside the blue ring.");
						}
						PlayerArenaRoute route;
						string originGateId = (ArenaRegistry.TryGetRoute(context.PlayerId, out route) ? route.OriginGateId : string.Empty);
						_engine.Enqueue(new QueueEntry
						{
							Request = request,
							OriginGateId = originGateId,
							EnqueuedUtc = DateTime.UtcNow
						});
						ProcessEngineEffects();
						return ArenaRpcResult.Accepted("Joined the " + definition.DisplayName + " queue.");
					}
				}
				return ArenaRpcResult.Rejected("That arena is not fully configured.");
			}
			catch (Exception ex)
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogWarning((object)("Challenge request rejected: " + ex.Message));
				}
				return ArenaRpcResult.Rejected(ex.Message);
			}
		}

		private static ArenaRpcResult OnQueueCallAccepted(ArenaRequestContext context)
		{
			bool num = _engine != null && _engine.AcceptTurn(context.PlayerId);
			ProcessEngineEffects();
			if (!num)
			{
				return ArenaRpcResult.Rejected("Your arena call is no longer active.");
			}
			return ArenaRpcResult.Accepted("Arena turn accepted.");
		}

		private static ArenaRpcResult OnForfeitRequested(ArenaRequestContext context)
		{
			bool num = _engine != null && _engine.Forfeit(context.PlayerId);
			ProcessEngineEffects();
			if (!num)
			{
				return ArenaRpcResult.Rejected("You do not have an active arena challenge.");
			}
			return ArenaRpcResult.Accepted("Arena challenge forfeited.");
		}

		private static ArenaRpcResult OnLethalDamageReported(ArenaRequestContext context)
		{
			bool num = _engine != null && _engine.ReportLethalDamage(context.PlayerId);
			ProcessEngineEffects();
			if (!num)
			{
				return ArenaRpcResult.Rejected("You do not have an active arena challenge.");
			}
			return ArenaRpcResult.Accepted("Arena defeat recorded.");
		}

		private static ArenaRpcResult OnCombatStartArrived(ArenaRequestContext context)
		{
			ArenaSession arenaSession = _engine?.GetActiveSessions().FirstOrDefault((ArenaSession candidate) => candidate?.Request?.PlayerId == context.PlayerId);
			if (arenaSession == null)
			{
				return ArenaRpcResult.Rejected("No staged arena challenge is awaiting arrival.");
			}
			if (arenaSession.Phase == SessionPhase.Countdown || arenaSession.Phase == SessionPhase.Fighting || arenaSession.Phase == SessionPhase.Intermission)
			{
				return ArenaRpcResult.Accepted();
			}
			if (arenaSession.Phase != SessionPhase.Staging || arenaSession.ResourceSnapshot == null || !ArenaRegistry.TryGetArena(arenaSession.ArenaId, out var definition) || definition.Markers == null)
			{
				return ArenaRpcResult.Rejected("The staged challenge is not ready for Combat Start.");
			}
			if (!Near(context.Position, definition.Markers.CombatantStartPosition, 4f))
			{
				return ArenaRpcResult.Rejected("Combat Start arrival has not reached the server yet.");
			}
			CombatStartMoveRetryUtc.Remove(context.PlayerId);
			bool num = _engine.EnterCombatFloor(context.PlayerId, arenaSession.ResourceSnapshot);
			ProcessEngineEffects();
			if (!num)
			{
				return ArenaRpcResult.Rejected("Combat Start confirmation expired.");
			}
			return ArenaRpcResult.Accepted();
		}

		private static ArenaRpcResult OnAdminMutationRequested(ArenaRequestContext context, ArenaAdminMutation mutation)
		{
			if (!context.IsAdmin || mutation == null)
			{
				return ArenaRpcResult.Rejected("Only a server administrator may change an arena.");
			}
			try
			{
				string text = mutation.TargetId;
				ArenaDefinition definition4;
				bool flag;
				switch (mutation.Kind)
				{
				case ArenaAdminMutationKind.RegisterArena:
				{
					ArenaDefinition arenaDefinition = MergeArenaMutation(mutation.Arena);
					if (!Near(context.Position, arenaDefinition.CorePosition, 12f) && !ArenaRegistry.TryGetArena(arenaDefinition.ArenaId, out definition4))
					{
						return ArenaRpcResult.Rejected("Stand near the Arena Core to register it.");
					}
					if (arenaDefinition.Markers != null && ArenaRegistry.MarkerPositionIsSet(arenaDefinition.Markers.CombatantStartPosition) && !ArenaRegistry.IsWithinCombatRadius(arenaDefinition, arenaDefinition.Markers.CombatantStartPosition))
					{
						return ArenaRpcResult.Rejected("Combat Start must remain inside the blue combat-radius ring.");
					}
					flag = ArenaRegistry.RegisterArena(arenaDefinition);
					text = arenaDefinition.ArenaId;
					break;
				}
				case ArenaAdminMutationKind.RemoveArena:
				{
					string removalArenaId = ArenaRegistry.NormalizeId(mutation.TargetId);
					if (_engine.TryGetActiveSession(removalArenaId, out var _) || _engine.GetQueueSnapshot().Any((QueueEntry entry) => entry.Request.ArenaId == removalArenaId))
					{
						return ArenaRpcResult.Rejected("Finish the active challenge and empty its queue before removing the arena.");
					}
					if (ArenaRegistry.GetRouteSnapshot().Any((PlayerArenaRoute route) => route.ArenaId == removalArenaId))
					{
						return ArenaRpcResult.Rejected("Return all arena visitors before removing the arena.");
					}
					flag = ArenaRegistry.RemoveArena(removalArenaId);
					if (flag)
					{
						ArenaRpc.BroadcastArenaRemoval(removalArenaId);
						SaveWorldState();
						return ArenaRpcResult.Accepted("Arena removed.");
					}
					break;
				}
				case ArenaAdminMutationKind.SetMarkers:
				{
					if (!ArenaRegistry.TryGetArena(mutation.TargetId, out var definition3) || mutation.Markers == null || !ArenaRegistry.IsWithinCombatRadius(definition3, mutation.Markers.CombatantStartPosition))
					{
						return ArenaRpcResult.Rejected("Combat Start must be inside the blue combat-radius ring.");
					}
					flag = ArenaRegistry.SetMarkers(mutation.TargetId, mutation.Markers);
					text = mutation.TargetId;
					break;
				}
				case ArenaAdminMutationKind.SetMarker:
				{
					if (!Near(context.Position, mutation.MarkerPosition, 12f))
					{
						return ArenaRpcResult.Rejected("Stand near the marker to configure it.");
					}
					text = ArenaRegistry.NormalizeId(mutation.TargetId);
					if (text == null || !ArenaRegistry.TryGetArena(text, out var definition2))
					{
						return ArenaRpcResult.Rejected("Select a registered arena before placing markers.");
					}
					ArenaMarkerKind markerKind = (ArenaMarkerKind)mutation.MarkerKind;
					if (markerKind == ArenaMarkerKind.CombatantStart && !ArenaRegistry.IsWithinCombatRadius(definition2, mutation.MarkerPosition))
					{
						return ArenaRpcResult.Rejected("Combat Start must be inside the blue combat-radius ring.");
					}
					if (markerKind == ArenaMarkerKind.CombatantStart && ArenaRegistry.TryGetMarkerPosition(text, ArenaMarkerKind.CombatantStart, -1, out var position) && !SamePosition(position, mutation.MarkerPosition))
					{
						return ArenaRpcResult.Rejected("This arena already has a Combat Start. Remove it before placing another.");
					}
					flag = ArenaRegistry.SetMarker(text, markerKind, mutation.MarkerSlot, mutation.MarkerPosition);
					break;
				}
				case ArenaAdminMutationKind.RemoveMarker:
				{
					if (!Near(context.Position, mutation.MarkerPosition, 12f))
					{
						return ArenaRpcResult.Rejected("Stand near the marker to remove it.");
					}
					text = ArenaRegistry.NormalizeId(mutation.TargetId);
					if (text == null || !ArenaRegistry.TryGetArena(text, out definition4))
					{
						return ArenaRpcResult.Rejected("The marker's arena no longer exists.");
					}
					ArenaMarkerKind markerKind2 = (ArenaMarkerKind)mutation.MarkerKind;
					if (ArenaRegistry.TryGetMarkerPosition(text, markerKind2, mutation.MarkerSlot, out var position2) && !SamePosition(position2, mutation.MarkerPosition))
					{
						return ArenaRpcResult.Accepted("Duplicate beacon removed; the saved arena position was left unchanged.");
					}
					flag = ArenaRegistry.RemoveMarker(text, markerKind2, mutation.MarkerSlot);
					break;
				}
				case ArenaAdminMutationKind.RegisterGate:
				{
					ArenaGateDefinition gate = mutation.Gate;
					if (gate == null || !Near(context.Position, gate.Position, 12f))
					{
						return ArenaRpcResult.Rejected("Stand near the Arena Gate to configure it.");
					}
					if (ArenaRegistry.GetGatesForArena(gate.ArenaId).Count == 0)
					{
						gate.IsFallbackEntrance = true;
					}
					flag = ArenaRegistry.RegisterGate(gate);
					text = gate.ArenaId;
					if (!flag)
					{
						break;
					}
					foreach (ArenaGateDefinition item in ArenaRegistry.GetGatesForArena(gate.ArenaId))
					{
						ArenaRpc.BroadcastGateConfiguration(item);
					}
					break;
				}
				case ArenaAdminMutationKind.RemoveGate:
				{
					ArenaRegistry.TryGetGate(mutation.TargetId, out var definition);
					flag = ArenaRegistry.RemoveGate(mutation.TargetId);
					text = definition?.ArenaId;
					break;
				}
				case ArenaAdminMutationKind.SetAdminTerrainPermission:
					ArenaConfig.AllowAdminTerrainEditing.Value = mutation.Enabled;
					ArenaConfig.Save();
					BroadcastAllArenaStates();
					return ArenaRpcResult.Accepted("Admin terrain editing " + (mutation.Enabled ? "enabled." : "disabled."));
				case ArenaAdminMutationKind.SetAdminBuildingPermission:
					ArenaConfig.AllowAdminBuilding.Value = mutation.Enabled;
					ArenaConfig.Save();
					BroadcastAllArenaStates();
					return ArenaRpcResult.Accepted("Admin building and demolition " + (mutation.Enabled ? "enabled." : "disabled."));
				case ArenaAdminMutationKind.SetAdminPickupPermission:
					ArenaConfig.AllowAdminDroppedItemPickup.Value = mutation.Enabled;
					ArenaConfig.Save();
					BroadcastAllArenaStates();
					return ArenaRpcResult.Accepted("Admin dropped-item pickup " + (mutation.Enabled ? "enabled." : "disabled."));
				case ArenaAdminMutationKind.RequestAdminStatus:
					return ArenaRpcResult.Accepted(BuildAdminStatus(mutation.TargetId));
				case ArenaAdminMutationKind.AbortArena:
					return AbortArenaForAdministration(mutation.TargetId, all: false);
				case ArenaAdminMutationKind.AbortAllArenas:
					return AbortArenaForAdministration("all", all: true);
				case ArenaAdminMutationKind.ClearArenaQueue:
					return ClearArenaQueueForAdministration(mutation.TargetId);
				default:
					return ArenaRpcResult.Rejected("Unknown arena administration request.");
				}
				if (!flag)
				{
					return ArenaRpcResult.Rejected("The change conflicts with an existing arena or gate name.");
				}
				SaveWorldState();
				if (!string.IsNullOrWhiteSpace(text))
				{
					ArenaRpc.BroadcastArenaState(text);
				}
				return ArenaRpcResult.Accepted("Arena configuration saved.");
			}
			catch (Exception ex)
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogWarning((object)("Admin mutation rejected: " + ex.Message));
				}
				return ArenaRpcResult.Rejected(ex.Message);
			}
		}

		private static ArenaRpcResult AbortArenaForAdministration(string target, bool all)
		{
			if (_engine == null)
			{
				return ArenaRpcResult.Rejected("Arena session service is not ready.");
			}
			ArenaDefinition arena;
			List<ArenaDefinition> list = (all ? ArenaRegistry.GetArenaSnapshot().ToList() : (TryResolveAdminArena(target, out arena) ? new List<ArenaDefinition> { arena } : null));
			if (list == null || list.Count == 0)
			{
				return ArenaRpcResult.Rejected("No matching arena was found.");
			}
			int num = 0;
			int num2 = 0;
			foreach (ArenaDefinition item in list)
			{
				num2 += _engine.ClearQueue(item.ArenaId);
				if (_engine.AbortArena(item.ArenaId))
				{
					num++;
				}
			}
			ProcessEngineEffects();
			SaveWorldState();
			return ArenaRpcResult.Accepted("Emergency recovery: " + num + " challenge(s) stopped, " + num2 + " queued player(s) cleared.");
		}

		private static ArenaRpcResult ClearArenaQueueForAdministration(string target)
		{
			if (_engine == null)
			{
				return ArenaRpcResult.Rejected("Arena session service is not ready.");
			}
			int num = 0;
			if (string.Equals(target?.Trim(), "all", StringComparison.OrdinalIgnoreCase))
			{
				foreach (ArenaDefinition item in ArenaRegistry.GetArenaSnapshot())
				{
					num += _engine.ClearQueue(item.ArenaId);
				}
			}
			else
			{
				if (!TryResolveAdminArena(target, out var arena))
				{
					return ArenaRpcResult.Rejected("No matching arena was found.");
				}
				num = _engine.ClearQueue(arena.ArenaId);
			}
			ProcessEngineEffects();
			SaveWorldState();
			return ArenaRpcResult.Accepted("Cleared " + num + " queued player(s).");
		}

		private static string BuildAdminStatus(string target)
		{
			if (_engine == null)
			{
				return "Arena session service is not ready.";
			}
			if (!string.IsNullOrWhiteSpace(target) && !string.Equals(target.Trim(), "all", StringComparison.OrdinalIgnoreCase))
			{
				if (!TryResolveAdminArena(target, out var arena))
				{
					return "No matching arena was found.";
				}
				_engine.TryGetActiveSession(arena.ArenaId, out var session);
				int num = _engine.GetQueueSnapshot().Count((QueueEntry entry) => string.Equals(entry.Request.ArenaId, arena.ArenaId, StringComparison.OrdinalIgnoreCase));
				int num2 = Enemies.Values.Count((ArenaEnemyHandle enemy) => string.Equals(enemy.ArenaId, arena.ArenaId, StringComparison.OrdinalIgnoreCase));
				return arena.DisplayName + ": " + (arena.Enabled ? "enabled" : "disabled") + ", phase=" + (session?.Phase.ToString() ?? "idle") + ", fighter=" + (session?.Request?.PlayerName ?? "none") + ", queue=" + num + ", enemies=" + num2 + ".";
			}
			List<ArenaDefinition> list = ArenaRegistry.GetArenaSnapshot().ToList();
			int count = _engine.GetActiveSessions().Count;
			int count2 = _engine.GetQueueSnapshot().Count;
			return "SkaldHall 0.0.3: arenas=" + list.Count + ", enabled=" + list.Count((ArenaDefinition arenaDefinition) => arenaDefinition.Enabled) + ", active=" + count + ", queued=" + count2 + ", enemies=" + Enemies.Count + ", pending restores=" + PendingRestores.Count + ".";
		}

		private static bool TryResolveAdminArena(string target, out ArenaDefinition arena)
		{
			arena = null;
			string clean = target?.Trim();
			if (string.IsNullOrWhiteSpace(clean))
			{
				return false;
			}
			string text = ArenaRegistry.NormalizeId(clean);
			if (text != null && ArenaRegistry.TryGetArena(text, out arena))
			{
				return true;
			}
			arena = ArenaRegistry.GetArenaSnapshot().FirstOrDefault((ArenaDefinition candidate) => candidate != null && string.Equals(candidate.DisplayName?.Trim(), clean, StringComparison.OrdinalIgnoreCase));
			return arena != null;
		}

		private static ArenaRpcResult OnGateTravelAuthorizing(ArenaRequestContext context, ArenaGateDefinition gate, bool returning)
		{
			if (returning)
			{
				return ArenaRpcResult.Accepted();
			}
			if (!ArenaRegistry.RecordRoute(new PlayerArenaRoute
			{
				PlayerId = context.PlayerId,
				ArenaId = gate.ArenaId,
				OriginGateId = gate.GateId,
				EnteredUtc = DateTime.UtcNow
			}) || !SaveWorldState())
			{
				ArenaRegistry.ClearRoute(context.PlayerId);
				return ArenaRpcResult.Rejected("The arena route could not be saved.");
			}
			return ArenaRpcResult.Accepted();
		}

		private static ArenaRpcResult OnGateTravelCompleted(ArenaRequestContext context, ArenaGateTravelAuthorization authorization, bool accepted)
		{
			if (!accepted)
			{
				if (!authorization.Returning)
				{
					ArenaRegistry.ClearRoute(context.PlayerId);
					SaveWorldState();
				}
				return ArenaRpcResult.Rejected("Arena travel was cancelled.");
			}
			if (authorization.Returning)
			{
				_engine?.Disconnect(context.PlayerId);
				ProcessEngineEffects();
				ArenaRegistry.ClearRoute(context.PlayerId);
				SetRole(context.PlayerId, ArenaRole.Visitor);
			}
			else
			{
				SetRole(context.PlayerId, ArenaRole.Spectator);
			}
			SaveWorldState();
			ArenaRpc.BroadcastArenaState(authorization.ArenaId);
			return ArenaRpcResult.Accepted();
		}

		private static bool OnClientGateTravelAuthorized(ArenaGateTravelAuthorization authorization)
		{
			int num;
			if (authorization != null)
			{
				num = (ArenaTeleporters.ApplyAuthorizedGateTravel(authorization.Destination, authorization.RotationY) ? 1 : 0);
				if (num != 0 && (Object)(object)Player.m_localPlayer != (Object)null)
				{
					SetRole(Player.m_localPlayer.GetPlayerID(), (!authorization.Returning) ? ArenaRole.Spectator : ArenaRole.Visitor);
				}
			}
			else
			{
				num = 0;
			}
			return (byte)num != 0;
		}

		private static ArenaRpcResult OnResourceSnapshotReceived(ArenaRequestContext context, PlayerResourceSnapshot snapshot)
		{
			if (snapshot == null || snapshot.PlayerId != context.PlayerId || _engine == null)
			{
				return ArenaRpcResult.Rejected("The resource snapshot is invalid.");
			}
			HashSet<string> eligiblePrefabNames = new HashSet<string>(from food in GetArenaFoods(null, requireKnown: false)
				select food.PrefabName, StringComparer.Ordinal);
			if (!ArenaFoodSelectionPolicy.IsValid(snapshot.ArenaFoodPrefabNames, eligiblePrefabNames))
			{
				return ArenaRpcResult.Rejected("Choose exactly three valid arena foods before starting.");
			}
			bool num = _engine.SetResourceSnapshot(context.PlayerId, snapshot);
			if (num)
			{
				ResourceSnapshots[context.PlayerId] = snapshot;
			}
			ProcessEngineEffects();
			if (!num)
			{
				return ArenaRpcResult.Rejected("The challenge is not waiting for a resource snapshot.");
			}
			return ArenaRpcResult.Accepted("Arena food prepared and pre-challenge resources saved.");
		}

		private static bool OnClientResourceRestoreRequested(PlayerResourceSnapshot snapshot, SessionOutcome outcome)
		{
			if (snapshot == null || (Object)(object)Player.m_localPlayer == (Object)null || snapshot.PlayerId != Player.m_localPlayer.GetPlayerID())
			{
				return false;
			}
			string[] obj = new string[5]
			{
				snapshot.PlayerId.ToString(),
				":",
				snapshot.CapturedUtc.Ticks.ToString(),
				":",
				null
			};
			int num = (int)outcome;
			obj[4] = num.ToString();
			string item = string.Concat(obj);
			if (ClientRestoredSnapshots.Contains(item))
			{
				return true;
			}
			ResourceSnapshots[snapshot.PlayerId] = snapshot;
			bool flag = RestoreResources(snapshot.PlayerId, outcome);
			if (flag)
			{
				foreach (string item2 in (from pair in ClientPreparations
					where pair.Value?.Snapshot?.PlayerId == snapshot.PlayerId
					select pair.Key).ToList())
				{
					ClientPreparations.Remove(item2);
					ClientFoodPrompts.Remove(item2);
					ArenaUi.CloseFoodPreparation(item2);
				}
				ClientRestoredSnapshots.Add(item);
			}
			return flag;
		}

		private static void OnResourceRestoreCompleted(ArenaRequestContext context, string token, bool success)
		{
			if (success)
			{
				PendingRestores.TryGetValue(context.PlayerId, out var value);
				PendingRestores.Remove(context.PlayerId);
				ResourceSnapshots.Remove(context.PlayerId);
				SaveWorldState();
				if (value?.Session != null)
				{
					ArenaRpc.BroadcastArenaState(value.Session.ArenaId);
				}
			}
			else
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogWarning((object)("Resource restoration was rejected for player " + context.PlayerId + "."));
				}
			}
		}

		private static bool OnClientMoveRequested(PositionData destination, float rotationY)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer != (Object)null)
			{
				return ((Character)localPlayer).TeleportTo(ToVector3(destination), Quaternion.Euler(0f, rotationY, 0f), false);
			}
			return false;
		}

		private static void OnClientSnapshotReceived(ArenaClientSnapshot snapshot)
		{
			if (snapshot == null)
			{
				return;
			}
			ArenaDefinition obj = new ArenaDefinition
			{
				ArenaId = snapshot.ArenaId,
				DisplayName = (string.IsNullOrWhiteSpace(snapshot.ArenaName) ? "Arena" : snapshot.ArenaName),
				CorePosition = snapshot.CorePosition,
				CombatRadius = snapshot.CombatRadius,
				ProtectedRadius = snapshot.ProtectedRadius,
				Markers = CopyMarkers(snapshot.Markers)
			};
			ArenaMarkerSet markers = snapshot.Markers;
			obj.Enabled = markers != null && markers.EnemySpawnPositions?.Count == 4;
			obj.Revision = 1L;
			ArenaDefinition definition = obj;
			try
			{
				ArenaRegistry.RegisterArena(definition);
				ArenaWorldObjects.ApplyArenaConfiguration(snapshot.ArenaId, snapshot.ArenaName);
			}
			catch (Exception ex)
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogWarning((object)("Ignored malformed arena snapshot: " + ex.Message));
				}
				return;
			}
			ClientArenaSnapshots[snapshot.ArenaId] = snapshot;
			_clientAdminsMayModifyTerrain = snapshot.AdminsMayModifyTerrain;
			_clientAdminsMayBuild = snapshot.AdminsMayBuild;
			_clientAdminsMayPickupDroppedItems = snapshot.AdminsMayPickupDroppedItems;
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer != (Object)null)
			{
				long playerID = localPlayer.GetPlayerID();
				bool flag = snapshot.CombatantPlayerId == playerID && snapshot.Phase == SessionPhase.Called;
				bool flag2 = snapshot.CombatantPlayerId == playerID && (snapshot.Phase == SessionPhase.Staging || snapshot.Phase == SessionPhase.Countdown || snapshot.Phase == SessionPhase.Fighting || snapshot.Phase == SessionPhase.Intermission);
				RecomputeClientRole();
				ClientQueuePromptSessions.TryGetValue(snapshot.ArenaId, out var value);
				if (ArenaQueuePromptPolicy.ShouldOpen(flag, value, snapshot.SessionId) && ArenaUi.ShowQueueCall(snapshot.ArenaId, snapshot.SessionId, Math.Max(1, snapshot.CountdownSeconds)))
				{
					ClientQueuePromptSessions[snapshot.ArenaId] = snapshot.SessionId;
				}
				else if (!flag)
				{
					ClientQueuePromptSessions.Remove(snapshot.ArenaId);
					ArenaUi.CloseQueuePromptForArena(snapshot.ArenaId);
				}
				if (snapshot.CombatantPlayerId == playerID && snapshot.PreparationComplete && ClientPreparations.TryGetValue(snapshot.ArenaId, out var value2))
				{
					value2.Accepted = true;
					ClientFoodPrompts.Remove(snapshot.ArenaId);
					ArenaUi.CloseFoodPreparation(snapshot.ArenaId);
				}
				if (flag2 && snapshot.Phase == SessionPhase.Staging && !snapshot.PreparationComplete)
				{
					if (ClientPreparations.TryGetValue(snapshot.ArenaId, out var value3) && !value3.Accepted && DateTime.UtcNow >= value3.SubmittedUtc.AddSeconds(2.0))
					{
						value3.SubmittedUtc = DateTime.UtcNow;
						value3.SubmissionAttempts++;
						ArenaRpc.SubmitResourceSnapshot(value3.Snapshot);
					}
					if (!ClientPreparations.ContainsKey(snapshot.ArenaId) && !ClientFoodPrompts.Contains(snapshot.ArenaId) && OpenLocalFoodPreparation(snapshot))
					{
						ClientFoodPrompts.Add(snapshot.ArenaId);
					}
				}
				else if (!flag2)
				{
					ClientFoodPrompts.Remove(snapshot.ArenaId);
					ArenaUi.CloseFoodPreparation(snapshot.ArenaId);
					if (snapshot.Phase == SessionPhase.Closed && ClientPreparations.TryGetValue(snapshot.ArenaId, out var value4) && !value4.Accepted)
					{
						RollBackLocalPreparation(snapshot.ArenaId, null);
					}
				}
			}
			ArenaUi.RenderSnapshot(snapshot);
		}

		private static void OnClientArenaRemoved(string arenaId)
		{
			arenaId = ArenaRegistry.NormalizeId(arenaId);
			if (arenaId != null)
			{
				ArenaRegistry.RemoveArena(arenaId);
				ClientArenaSnapshots.Remove(arenaId);
				ClientCombatStartArrivalRetryUtc.Remove(arenaId);
				ClientFoodPrompts.Remove(arenaId);
				if (ClientPreparations.TryGetValue(arenaId, out var value) && !value.Accepted)
				{
					RollBackLocalPreparation(arenaId, null);
				}
				ClientPreparations.Remove(arenaId);
				ClientQueuePromptSessions.Remove(arenaId);
				RecomputeClientRole();
				ArenaUi.OnArenaRemoved(arenaId);
			}
		}

		private static void RecomputeClientRole()
		{
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null)
			{
				return;
			}
			long playerId = localPlayer.GetPlayerID();
			IEnumerable<ArenaClientSnapshot> values = ClientArenaSnapshots.Values;
			if (values.Any((ArenaClientSnapshot candidate) => candidate.CombatantPlayerId == playerId && (candidate.Phase == SessionPhase.Staging || candidate.Phase == SessionPhase.Countdown || candidate.Phase == SessionPhase.Fighting || candidate.Phase == SessionPhase.Intermission)))
			{
				SetRole(playerId, ArenaRole.Combatant);
				return;
			}
			if (values.Any((ArenaClientSnapshot candidate) => candidate.QueuePosition > 0 || (candidate.CombatantPlayerId == playerId && candidate.Phase == SessionPhase.Called)))
			{
				SetRole(playerId, ArenaRole.Queued);
				return;
			}
			PositionData position = ToPositionData(((Component)localPlayer).transform.position);
			bool flag = values.Any((ArenaClientSnapshot candidate) => Near(position, candidate.CorePosition, candidate.ProtectedRadius));
			SetRole(playerId, flag ? ArenaRole.Spectator : ArenaRole.Visitor);
		}

		private static void ReportClientCombatStartArrival()
		{
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null || ((Character)localPlayer).IsTeleporting())
			{
				return;
			}
			float unscaledTime = Time.unscaledTime;
			if (unscaledTime < _nextClientCombatStartArrivalCheckTime)
			{
				return;
			}
			_nextClientCombatStartArrivalCheckTime = unscaledTime + 0.1f;
			long playerID = localPlayer.GetPlayerID();
			DateTime utcNow = DateTime.UtcNow;
			PositionData first = ToPositionData(((Component)localPlayer).transform.position);
			foreach (ArenaClientSnapshot value3 in ClientArenaSnapshots.Values)
			{
				if (value3 == null || value3.CombatantPlayerId != playerID || value3.Phase != SessionPhase.Staging || value3.Markers == null)
				{
					continue;
				}
				DateTime value;
				bool flag = ClientCombatStartArrivalRetryUtc.TryGetValue(value3.ArenaId, out value) && utcNow < value;
				if (Near(first, value3.Markers.CombatantStartPosition, 4f))
				{
					if (!flag)
					{
						ClientCombatStartArrivalRetryUtc[value3.ArenaId] = utcNow.AddSeconds(1.0);
						ArenaRpc.ReportCombatStartArrival();
					}
				}
				else if (!flag && value3.PreparationComplete)
				{
					ClientCombatStartArrivalRetryUtc[value3.ArenaId] = utcNow.AddSeconds(1.0);
					OnClientMoveRequested(value3.Markers.CombatantStartPosition, 0f);
				}
			}
			StaleClientCombatStartArrivalArenaIds.Clear();
			foreach (KeyValuePair<string, DateTime> item in ClientCombatStartArrivalRetryUtc)
			{
				if (!ClientArenaSnapshots.TryGetValue(item.Key, out var value2) || value2 == null || value2.CombatantPlayerId != playerID || value2.Phase != SessionPhase.Staging)
				{
					StaleClientCombatStartArrivalArenaIds.Add(item.Key);
				}
			}
			foreach (string staleClientCombatStartArrivalArenaId in StaleClientCombatStartArrivalArenaIds)
			{
				ClientCombatStartArrivalRetryUtc.Remove(staleClientCombatStartArrivalArenaId);
			}
		}

		private static void OnClientLeaderboardReceived(LeaderboardKey key, List<LeaderboardEntry> entries)
		{
			ArenaUi.ReceiveLeaderboard(key, entries ?? new List<LeaderboardEntry>());
		}

		private static List<LeaderboardEntry> GetCurrentRosterLeaderboard(LeaderboardKey key)
		{
			long revision = _catalog?.RosterRevision ?? 0;
			return (from entry in ArenaStore.GetLeaderboard(key)
				where entry != null && entry.RosterRevision == revision
				select entry).ToList();
		}

		private static void OnClientActionResultReceived(bool success, string message)
		{
			if (!string.IsNullOrWhiteSpace(message) && (Object)(object)Player.m_localPlayer != (Object)null)
			{
				((Character)Player.m_localPlayer).Message((MessageType)(success ? 1 : 2), message, 0, (Sprite)null);
			}
		}

		private static void RequestPlacementMutation(ArenaWorldObjectPlacement placement)
		{
			if (placement == null || !ArenaWorldObjects.IsLocalAdmin())
			{
				return;
			}
			switch (placement.Kind)
			{
			case ArenaWorldObjectKind.Core:
				ArenaRpc.RequestAdminMutation(new ArenaAdminMutation
				{
					Kind = ArenaAdminMutationKind.RegisterArena,
					Arena = new ArenaDefinition
					{
						ArenaId = placement.ObjectId,
						DisplayName = "Arena " + ShortId(placement.ObjectId),
						CorePosition = placement.Position,
						CombatRadius = ArenaConfig.DefaultCombatRadius.Value,
						ProtectedRadius = ArenaConfig.DefaultProtectedRadius.Value,
						Markers = null,
						Enabled = false,
						Revision = 1L
					}
				});
				ArenaWorldObjects.SelectAdminArena(placement.ObjectId);
				break;
			case ArenaWorldObjectKind.EntranceGate:
				if (!string.IsNullOrWhiteSpace(placement.ArenaId))
				{
					ArenaRpc.RequestAdminMutation(new ArenaAdminMutation
					{
						Kind = ArenaAdminMutationKind.RegisterGate,
						Gate = new ArenaGateDefinition
						{
							GateId = placement.ObjectId,
							ArenaId = placement.ArenaId,
							DisplayName = "Arena Gate " + ShortId(placement.ObjectId),
							Position = placement.Position,
							RotationY = placement.RotationY,
							IsFallbackEntrance = false
						}
					});
				}
				break;
			case ArenaWorldObjectKind.HubGate:
				RequestMarkerMutation(placement.ArenaId, ArenaMarkerKind.HubGate, placement.Position, -1);
				break;
			case ArenaWorldObjectKind.Sign:
			case ArenaWorldObjectKind.StagingMarker:
			case ArenaWorldObjectKind.CombatantStartMarker:
			case ArenaWorldObjectKind.EnemySpawnMarker:
			case ArenaWorldObjectKind.HubGateMarker:
				break;
			}
		}

		private static void RequestCoreRemoval(string arenaId)
		{
			arenaId = ArenaRegistry.NormalizeId(arenaId);
			if (arenaId != null && ArenaWorldObjects.IsLocalAdmin())
			{
				ArenaRpc.RequestAdminMutation(new ArenaAdminMutation
				{
					Kind = ArenaAdminMutationKind.RemoveArena,
					TargetId = arenaId
				});
			}
		}

		private static void RequestStaleCoreCleanup(string arenaId, PositionData position)
		{
			arenaId = ArenaRegistry.NormalizeId(arenaId);
			if (arenaId == null || !ArenaWorldObjects.IsLocalAdmin())
			{
				return;
			}
			foreach (ArenaDefinition item in ArenaRegistry.GetArenaSnapshot())
			{
				if (item == null || string.Equals(item.ArenaId, arenaId, StringComparison.Ordinal))
				{
					continue;
				}
				float num = item.CorePosition.X - position.X;
				float num2 = item.CorePosition.Y - position.Y;
				float num3 = item.CorePosition.Z - position.Z;
				if (!(num * num + num2 * num2 + num3 * num3 > 4f))
				{
					ManualLogSource log = Plugin.Log;
					if (log != null)
					{
						log.LogInfo((object)("Removing stale arena definition " + item.ArenaId + " replaced by Core " + arenaId + "."));
					}
					ArenaRpc.RequestAdminMutation(new ArenaAdminMutation
					{
						Kind = ArenaAdminMutationKind.RemoveArena,
						TargetId = item.ArenaId
					});
				}
			}
		}

		private static int RequestMarkerMutation(string arenaId, ArenaMarkerKind kind, PositionData position, int slot)
		{
			arenaId = ArenaRegistry.NormalizeId(arenaId);
			if (arenaId == null || !ArenaWorldObjects.IsLocalAdmin())
			{
				return -2;
			}
			if (kind == ArenaMarkerKind.CombatantStart && ArenaRegistry.TryGetArena(arenaId, out var definition) && !ArenaRegistry.IsWithinCombatRadius(definition, position))
			{
				Player localPlayer = Player.m_localPlayer;
				if (localPlayer != null)
				{
					((Character)localPlayer).Message((MessageType)2, "Combat Start must be inside the blue combat-radius ring.", 0, (Sprite)null);
				}
				return -2;
			}
			if (kind == ArenaMarkerKind.CombatantStart && ArenaRegistry.TryGetMarkerPosition(arenaId, ArenaMarkerKind.CombatantStart, -1, out var position2) && !SamePosition(position2, position))
			{
				Player localPlayer2 = Player.m_localPlayer;
				if (localPlayer2 != null)
				{
					((Character)localPlayer2).Message((MessageType)2, "This arena already has a Combat Start. Remove it before placing another.", 0, (Sprite)null);
				}
				return -2;
			}
			int num = ((kind == ArenaMarkerKind.EnemySpawn && slot < 0) ? ArenaRegistry.NextAvailableEnemyMarkerSlot(arenaId) : slot);
			if (kind == ArenaMarkerKind.EnemySpawn && num < 0)
			{
				Player localPlayer3 = Player.m_localPlayer;
				if (localPlayer3 != null)
				{
					((Character)localPlayer3).Message((MessageType)2, "This arena already has four Enemy Spawn beacons. Remove one before placing another.", 0, (Sprite)null);
				}
				return -2;
			}
			ArenaRpc.RequestAdminMutation(new ArenaAdminMutation
			{
				Kind = ArenaAdminMutationKind.SetMarker,
				TargetId = arenaId,
				MarkerKind = (int)kind,
				MarkerSlot = num,
				MarkerPosition = position
			});
			return num;
		}

		private static void RequestMarkerRemoval(string arenaId, ArenaMarkerKind kind, PositionData position, int slot)
		{
			arenaId = ArenaRegistry.NormalizeId(arenaId);
			if (arenaId != null && ArenaWorldObjects.IsLocalAdmin())
			{
				ArenaRpc.RequestAdminMutation(new ArenaAdminMutation
				{
					Kind = ArenaAdminMutationKind.RemoveMarker,
					TargetId = arenaId,
					MarkerKind = (int)kind,
					MarkerSlot = slot,
					MarkerPosition = position
				});
			}
		}

		private static void RequestGateConfiguration(string objectId, string arenaId, string displayName, bool isFallback)
		{
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			ArenaGateBehaviour arenaGateBehaviour = Object.FindObjectsByType<ArenaGateBehaviour>((FindObjectsInactive)0, (FindObjectsSortMode)0).FirstOrDefault((ArenaGateBehaviour candidate) => (Object)(object)candidate != (Object)null && candidate.ObjectId == objectId);
			if (!((Object)(object)arenaGateBehaviour == (Object)null) && !arenaGateBehaviour.IsHubGate)
			{
				ArenaRpc.RequestAdminMutation(new ArenaAdminMutation
				{
					Kind = ArenaAdminMutationKind.RegisterGate,
					Gate = new ArenaGateDefinition
					{
						GateId = objectId,
						ArenaId = arenaId,
						DisplayName = displayName,
						Position = ToPositionData(((Component)arenaGateBehaviour).transform.position),
						RotationY = ((Component)arenaGateBehaviour).transform.eulerAngles.y,
						IsFallbackEntrance = isFallback
					}
				});
			}
		}

		private static void RequestUiAdminMutation(ArenaUiAdminMutation mutation)
		{
			if (mutation == null)
			{
				return;
			}
			ArenaDefinition definition;
			if (!ArenaWorldObjects.IsLocalAdmin())
			{
				Player localPlayer = Player.m_localPlayer;
				if (localPlayer != null)
				{
					((Character)localPlayer).Message((MessageType)2, "Only an authenticated administrator may change arena settings.", 0, (Sprite)null);
				}
			}
			else if (mutation.Kind == ArenaUiAdminMutationKind.SetTerrainPermission || mutation.Kind == ArenaUiAdminMutationKind.SetBuildingPermission || mutation.Kind == ArenaUiAdminMutationKind.SetPickupPermission)
			{
				string text = ArenaRegistry.NormalizeId(mutation.ArenaId);
				if (text == null)
				{
					Player localPlayer2 = Player.m_localPlayer;
					if (localPlayer2 != null)
					{
						((Character)localPlayer2).Message((MessageType)2, "This Arena Core does not have a valid server ID yet.", 0, (Sprite)null);
					}
				}
				else
				{
					ArenaAdminMutationKind kind = ((mutation.Kind == ArenaUiAdminMutationKind.SetTerrainPermission) ? ArenaAdminMutationKind.SetAdminTerrainPermission : ((mutation.Kind == ArenaUiAdminMutationKind.SetBuildingPermission) ? ArenaAdminMutationKind.SetAdminBuildingPermission : ArenaAdminMutationKind.SetAdminPickupPermission));
					ArenaRpc.RequestAdminMutation(new ArenaAdminMutation
					{
						Kind = kind,
						TargetId = text,
						Enabled = mutation.Enabled
					});
				}
			}
			else if (!ArenaRegistry.TryGetArena(mutation.ArenaId, out definition))
			{
				Player localPlayer3 = Player.m_localPlayer;
				if (localPlayer3 != null)
				{
					((Character)localPlayer3).Message((MessageType)2, "The selected arena is not synchronized with the server yet.", 0, (Sprite)null);
				}
			}
			else
			{
				if (mutation.Kind == ArenaUiAdminMutationKind.SaveDefinition)
				{
					definition.DisplayName = mutation.DisplayName;
					definition.CombatRadius = mutation.CombatRadius;
					definition.ProtectedRadius = mutation.ProtectedRadius;
				}
				else
				{
					definition.Enabled = mutation.Kind == ArenaUiAdminMutationKind.EnableArena;
				}
				ArenaRpc.RequestAdminMutation(new ArenaAdminMutation
				{
					Kind = ArenaAdminMutationKind.RegisterArena,
					Arena = definition
				});
			}
		}

		private static ArenaDefinition MergeArenaMutation(ArenaDefinition requested)
		{
			if (requested == null)
			{
				throw new ArgumentNullException("requested");
			}
			if (!ArenaRegistry.TryGetArena(requested.ArenaId, out var definition))
			{
				return requested;
			}
			requested.CorePosition = definition.CorePosition;
			requested.Markers = requested.Markers ?? definition.Markers;
			requested.Revision = Math.Max(requested.Revision, definition.Revision + 1);
			return requested;
		}

		private static void DetectFloorEntryAndBoundary()
		{
			if (_engine == null)
			{
				return;
			}
			ActiveCombatantIds.Clear();
			AwaitingCombatStartIds.Clear();
			foreach (ArenaSession activeSession in _engine.GetActiveSessions())
			{
				if (activeSession?.Request == null || !ArenaRegistry.TryGetArena(activeSession.ArenaId, out var definition))
				{
					continue;
				}
				if (!TryResolvePlayerState(activeSession.Request.PlayerId, out var _, out var position, out var _))
				{
					if (activeSession.Phase == SessionPhase.Countdown || activeSession.Phase == SessionPhase.Fighting || activeSession.Phase == SessionPhase.Intermission)
					{
						_engine.Disconnect(activeSession.Request.PlayerId);
					}
					continue;
				}
				bool flag = !Near(position, definition.CorePosition, definition.CombatRadius);
				if (ArenaStartPolicy.ShouldTeleportToCombatStart(activeSession.Phase, activeSession.ResourceSnapshot != null))
				{
					long playerId = activeSession.Request.PlayerId;
					AwaitingCombatStartIds.Add(playerId);
					bool combatStartArrivalConfirmed = Near(position, definition.Markers.CombatantStartPosition, 4f);
					if (ArenaStartPolicy.ShouldBeginCountdown(activeSession.Phase, activeSession.ResourceSnapshot != null, combatStartArrivalConfirmed))
					{
						CombatStartMoveRetryUtc.Remove(playerId);
						_engine.EnterCombatFloor(playerId, activeSession.ResourceSnapshot);
						continue;
					}
					DateTime utcNow = DateTime.UtcNow;
					if (!CombatStartMoveRetryUtc.TryGetValue(playerId, out var value) || utcNow >= value)
					{
						ArenaRpc.SendPlayerMove(playerId, definition.Markers.CombatantStartPosition);
						CombatStartMoveRetryUtc[playerId] = utcNow.AddSeconds(1.0);
					}
				}
				else if (activeSession.Phase == SessionPhase.Countdown || activeSession.Phase == SessionPhase.Fighting || activeSession.Phase == SessionPhase.Intermission)
				{
					long playerId2 = activeSession.Request.PlayerId;
					ActiveCombatantIds.Add(playerId2);
					HandleCombatBoundary(activeSession, definition, flag);
					_engine.ReportBoundaryState(playerId2, flag);
					if (activeSession.Phase == SessionPhase.Fighting)
					{
						RepositionEscapedOrStuckEnemies(activeSession.SessionId);
					}
				}
			}
			StaleCombatantIds.Clear();
			foreach (long key in CombatStartMoveRetryUtc.Keys)
			{
				if (!AwaitingCombatStartIds.Contains(key))
				{
					StaleCombatantIds.Add(key);
				}
			}
			foreach (long staleCombatantId in StaleCombatantIds)
			{
				CombatStartMoveRetryUtc.Remove(staleCombatantId);
			}
			StaleCombatantIds.Clear();
			foreach (long key2 in CombatBoundaryStates.Keys)
			{
				if (!ActiveCombatantIds.Contains(key2))
				{
					StaleCombatantIds.Add(key2);
				}
			}
			foreach (long staleCombatantId2 in StaleCombatantIds)
			{
				CombatBoundaryStates.Remove(staleCombatantId2);
			}
		}

		private static void HandleCombatBoundary(ArenaSession session, ArenaDefinition arena, bool outside)
		{
			if (session?.Request == null || arena == null)
			{
				return;
			}
			long playerId = session.Request.PlayerId;
			if (!CombatBoundaryStates.TryGetValue(playerId, out var value) || !string.Equals(value.ArenaId, arena.ArenaId, StringComparison.Ordinal))
			{
				value = new CombatBoundaryState
				{
					ArenaId = arena.ArenaId
				};
				CombatBoundaryStates[playerId] = value;
			}
			if (!outside)
			{
				if (value.OutsideSinceUtc != DateTime.MinValue)
				{
					SendPlayerPopup(playerId, "ARENA BOUNDARY CLEARED\nChallenge continuing.");
				}
				value.OutsideSinceUtc = DateTime.MinValue;
				value.NextPopupUtc = DateTime.MinValue;
				return;
			}
			DateTime utcNow = DateTime.UtcNow;
			if (value.OutsideSinceUtc == DateTime.MinValue)
			{
				value.OutsideSinceUtc = utcNow;
				value.NextPopupUtc = DateTime.MinValue;
			}
			if (!(utcNow < value.NextPopupUtc))
			{
				int num = Math.Max(1, ArenaConfig.BoundaryGraceSeconds.Value);
				int num2 = Math.Max(1, (int)Math.Ceiling((double)num - (utcNow - value.OutsideSinceUtc).TotalSeconds));
				SendPlayerPopup(playerId, "RETURN TO THE ARENA\n" + num2 + ((num2 == 1) ? " second" : " seconds") + " remaining or challenge forfeited.");
				value.NextPopupUtc = utcNow.Add(CombatBoundaryPopupInterval);
			}
		}

		private static void ReconcileArenaEnemies()
		{
			HashSet<string> hashSet = new HashSet<string>(StringComparer.Ordinal);
			foreach (ArenaEnemyHandle item in Enemies.Values.ToList())
			{
				if (!((Object)(object)item.Character != (Object)null) || item.Character.IsDead() || !(item.Character.GetHealth() > 0f))
				{
					Enemies.Remove(item.EnemyId);
					hashSet.Add(item.SessionId);
				}
			}
			foreach (string sessionId in hashSet)
			{
				if (!Enemies.Values.Any((ArenaEnemyHandle handle) => string.Equals(handle.SessionId, sessionId, StringComparison.Ordinal)))
				{
					_engine.ReportEncounterCleared(sessionId);
				}
			}
		}

		private static void ProcessEngineEffects()
		{
			if (_engine == null)
			{
				return;
			}
			bool flag = false;
			int num = 0;
			while (num++ < 16)
			{
				IList<ArenaEffect> list = _engine.DrainEffects();
				if (list.Count == 0)
				{
					break;
				}
				flag = true;
				foreach (ArenaEffect item in list)
				{
					bool succeeded = ApplyEngineEffect(item);
					_engine.ApplyEffectResult(item, succeeded);
				}
			}
			DateTime utcNow = DateTime.UtcNow;
			if (flag || !(utcNow < _nextStateBroadcastUtc))
			{
				_nextStateBroadcastUtc = utcNow.AddSeconds(1.0);
				SyncRegistryFromEngine();
				BroadcastAllArenaStates();
			}
		}

		private static bool ApplyEngineEffect(ArenaEffect effect)
		{
			if (effect == null)
			{
				return false;
			}
			switch (effect.Type)
			{
			case ArenaEffectType.CallQueuedPlayer:
			case ArenaEffectType.StartCountdown:
				return true;
			case ArenaEffectType.MoveToStaging:
				return TrySendArenaMove(effect.PlayerId, effect.ArenaId, staging: true, IsTerminalMove(effect));
			case ArenaEffectType.SpawnEncounter:
			{
				if (!_engine.TryGetSession(effect.SessionId, out var session))
				{
					return false;
				}
				return SpawnEncounter(session, effect.Encounter).Count == effect.Encounter.Quantity;
			}
			case ArenaEffectType.DespawnSessionEnemies:
				DespawnSessionEnemies(effect.SessionId, effect.ArenaId);
				return true;
			case ArenaEffectType.RestorePlayerState:
				return QueueResourceRestore(effect);
			case ArenaEffectType.MoveToSpectatorArea:
				SetRole(effect.PlayerId, ArenaRole.Spectator);
				return TrySendArenaMove(effect.PlayerId, effect.ArenaId, staging: true, useArenaMasterExit: true);
			case ArenaEffectType.SetArenaRole:
			{
				if (Enum.TryParse<ArenaRole>(effect.Message, ignoreCase: true, out var result))
				{
					SetRole(effect.PlayerId, result);
					return true;
				}
				return false;
			}
			case ArenaEffectType.PersistState:
				return SaveWorldState();
			case ArenaEffectType.UpdateLeaderboard:
				return RecordLeaderboard(effect.SessionId);
			case ArenaEffectType.SendLocalMessage:
				SendPlayerMessage(effect.PlayerId, effect.Message);
				return true;
			case ArenaEffectType.SendGlobalMessage:
				SendGlobalMessage(effect.Message);
				return true;
			default:
				return false;
			}
		}

		private static bool QueueResourceRestore(ArenaEffect effect)
		{
			if (!_engine.TryGetSession(effect.SessionId, out var session) || session.ResourceSnapshot == null)
			{
				return false;
			}
			PendingRestore pendingRestore = new PendingRestore
			{
				PlayerId = effect.PlayerId,
				Snapshot = session.ResourceSnapshot,
				Outcome = ((session.Outcome == SessionOutcome.None) ? SessionOutcome.ServerRestart : session.Outcome),
				Session = session
			};
			PendingRestores[effect.PlayerId] = pendingRestore;
			if (!SaveWorldState())
			{
				return false;
			}
			return TrySendRestore(pendingRestore);
		}

		private static void RetryPendingRestores()
		{
			foreach (PendingRestore item in PendingRestores.Values.ToList())
			{
				if (DateTime.UtcNow >= item.NextAttemptUtc)
				{
					TrySendRestore(item);
				}
			}
		}

		private static bool TrySendRestore(PendingRestore restore)
		{
			restore.NextAttemptUtc = DateTime.UtcNow.AddSeconds(35.0);
			return ArenaRpc.SendResourceRestore(restore.PlayerId, restore.Snapshot, restore.Outcome);
		}

		private static bool TrySendArenaMove(long playerId, string arenaId, bool staging, bool useArenaMasterExit = false)
		{
			if (!ArenaRegistry.TryGetArena(arenaId, out var definition) || definition.Markers == null)
			{
				return false;
			}
			PositionData destination = (staging ? definition.Markers.StagingPosition : definition.Markers.CombatantStartPosition);
			float rotationY = 0f;
			if (staging && useArenaMasterExit)
			{
				TryResolveArenaMasterExit(definition, out destination, out rotationY);
			}
			Player player;
			PositionData position;
			ZNetPeer peer;
			bool flag = TryResolvePlayerState(playerId, out player, out position, out peer);
			if (staging && !useArenaMasterExit && flag && Near3D(position, destination, 4f))
			{
				return true;
			}
			return ArenaRpc.SendPlayerMove(playerId, destination, rotationY);
		}

		private static bool IsTerminalMove(ArenaEffect effect)
		{
			if (effect != null && _engine != null && _engine.TryGetSession(effect.SessionId, out var session))
			{
				return session.Outcome != SessionOutcome.None;
			}
			return false;
		}

		private static bool TryResolveArenaMasterExit(ArenaDefinition arena, out PositionData destination, out float rotationY)
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0109: Unknown result type (might be due to invalid IL or missing references)
			destination = arena.Markers.StagingPosition;
			rotationY = 0f;
			Character val = null;
			float num = 36f;
			Vector3 val2 = ToVector3(arena.Markers.StagingPosition);
			foreach (Character allCharacter in Character.GetAllCharacters())
			{
				if (ArenaWorldObjects.IsChallengeHost(allCharacter))
				{
					Vector3 val3 = ((Component)allCharacter).transform.position - val2;
					float sqrMagnitude = ((Vector3)(ref val3)).sqrMagnitude;
					if (sqrMagnitude <= num)
					{
						val = allCharacter;
						num = sqrMagnitude;
					}
				}
			}
			if ((Object)(object)val == (Object)null)
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogWarning((object)("Arena Master was not loaded while resolving the completion exit for " + arena.ArenaId + "; using the saved staging position."));
				}
				return false;
			}
			Transform transform = ((Component)val).transform;
			Vector3 position = transform.position + transform.forward * 3f + Vector3.up * 0.2f;
			destination = ToPositionData(position);
			rotationY = transform.eulerAngles.y;
			return true;
		}

		private static bool RecordLeaderboard(string sessionId)
		{
			if (!_engine.TryGetSession(sessionId, out var session) || session?.Plan == null || session.Request == null)
			{
				return false;
			}
			LeaderboardKey key = BuildLeaderboardKey(session);
			return ArenaStore.RecordResult(new LeaderboardEntry
			{
				Key = key,
				PlayerId = session.Request.PlayerId,
				PlayerName = session.Request.PlayerName,
				Completed = (session.Outcome == SessionOutcome.Victory),
				FurthestEncounterIndex = Math.Max(0, session.EncounterIndex),
				ElapsedMilliseconds = Math.Max(0L, session.ElapsedMilliseconds),
				RosterRevision = session.Plan.RosterRevision,
				RecordedUtc = DateTime.UtcNow
			});
		}

		private static LeaderboardKey BuildLeaderboardKey(ArenaSession session)
		{
			CustomEncounterSelection customSelection = session.Request.CustomSelection;
			return new LeaderboardKey
			{
				Mode = session.Plan.Mode,
				CapMode = session.Plan.CapMode,
				SelectedBiome = session.Request.SelectedBiome,
				CustomCreatureKey = (customSelection?.CreatureKey ?? string.Empty),
				CustomStars = (customSelection?.Stars ?? StarLevel.Base),
				CustomQuantity = (customSelection?.Quantity ?? 0)
			};
		}

		private static void SyncRegistryFromEngine()
		{
			if (_engine == null)
			{
				return;
			}
			ArenaRegistry.ReplaceQueue(_engine.GetQueueSnapshot());
			foreach (ArenaDefinition item in ArenaRegistry.GetArenaSnapshot())
			{
				ArenaRegistry.ClearActiveSession(item.ArenaId);
			}
			foreach (ArenaSession activeSession in _engine.GetActiveSessions())
			{
				if (ArenaRegistry.TryGetArena(activeSession.ArenaId, out var _))
				{
					ArenaRegistry.SetActiveSession(activeSession);
				}
			}
		}

		private static bool SaveWorldState()
		{
			if (_loadedWorldUid == 0L || (Object)(object)ZNet.instance == (Object)null || !ZNet.instance.IsServer() || _engine == null)
			{
				return false;
			}
			PersistedWorldState persistedWorldState = ArenaStore.Snapshot();
			List<QueueEntry> entries = _engine.GetQueueSnapshot().ToList();
			List<ArenaSession> list = new List<ArenaSession>();
			foreach (ArenaSession activeSession in _engine.GetActiveSessions())
			{
				list.Add(activeSession);
			}
			list.AddRange(from restore in PendingRestores.Values
				where restore.Session != null && restore.Session.ResourceSnapshot != null
				select restore.Session);
			ArenaRegistry.ReplaceQueue(entries);
			return ArenaStore.Save(ArenaRegistry.Snapshot(_loadedWorldUid, _catalog.RosterRevision, from session in list
				group session by session.SessionId into @group
				select @group.First(), persistedWorldState.Leaderboard));
		}

		private static ArenaClientSnapshot BuildClientSnapshot(string arenaId, long viewerPlayerId)
		{
			if (!ArenaRegistry.TryGetArena(arenaId, out var definition))
			{
				return null;
			}
			ArenaSession session = null;
			_engine?.TryGetActiveSession(arenaId, out session);
			bool flag = viewerPlayerId > 0 && PendingRestores.ContainsKey(viewerPlayerId);
			List<QueueEntry> list = (from entry in _engine?.GetQueueSnapshot() ?? new List<QueueEntry>()
				where entry.Request.ArenaId == arenaId
				orderby entry.QueueSequence
				select entry).ToList();
			int num = list.FindIndex((QueueEntry entry) => entry.Request.PlayerId == viewerPlayerId);
			EncounterDefinition currentEncounter = ((session?.Plan?.Encounters != null && session.EncounterIndex >= 0 && session.EncounterIndex < session.Plan.Encounters.Count) ? session.Plan.Encounters[session.EncounterIndex] : null);
			int num2 = ((session != null && !(session.PhaseDeadlineUtc == DateTime.MinValue)) ? Math.Max(0, (int)Math.Ceiling((session.PhaseDeadlineUtc - DateTime.UtcNow).TotalSeconds)) : 0);
			return new ArenaClientSnapshot
			{
				ArenaId = definition.ArenaId,
				SessionId = (session?.SessionId ?? string.Empty),
				ArenaName = definition.DisplayName,
				CorePosition = definition.CorePosition,
				CombatRadius = definition.CombatRadius,
				ProtectedRadius = definition.ProtectedRadius,
				Markers = CopyMarkers(definition.Markers),
				Phase = ((flag && session != null && session.Request?.PlayerId == viewerPlayerId) ? SessionPhase.Recovering : (session?.Phase ?? SessionPhase.Closed)),
				CombatantPlayerId = ((flag && session != null && session.Request?.PlayerId == viewerPlayerId) ? 0 : (session?.Request?.PlayerId).GetValueOrDefault()),
				CombatantName = ((flag && session != null && session.Request?.PlayerId == viewerPlayerId) ? string.Empty : (session?.Request?.PlayerName ?? string.Empty)),
				QueuePosition = ((num >= 0) ? (num + 1) : 0),
				QueueLength = list.Count,
				EncounterIndex = (session?.EncounterIndex ?? 0),
				EncounterCount = (session?.Plan?.Encounters?.Count).GetValueOrDefault(),
				CurrentEncounter = currentEncounter,
				CountdownSeconds = ((!flag) ? num2 : 0),
				ElapsedMilliseconds = (session?.ElapsedMilliseconds ?? 0),
				PreparationComplete = (session?.ResourceSnapshot != null),
				AdminsMayModifyTerrain = (ArenaConfig.AllowAdminTerrainEditing?.Value ?? false),
				AdminsMayBuild = (ArenaConfig.AllowAdminBuilding?.Value ?? false),
				AdminsMayPickupDroppedItems = (ArenaConfig.AllowAdminDroppedItemPickup?.Value ?? false)
			};
		}

		private static void BroadcastAllArenaStates()
		{
			if ((Object)(object)ZNet.instance == (Object)null || !ZNet.instance.IsServer())
			{
				return;
			}
			foreach (ArenaDefinition item in ArenaRegistry.GetArenaSnapshot())
			{
				ArenaRpc.BroadcastArenaState(item.ArenaId);
			}
		}

		private static void SendPlayerMessage(long playerId, string message)
		{
			if (!string.IsNullOrWhiteSpace(message) && !((Object)(object)ZNet.instance == (Object)null) && ZRoutedRpc.instance != null)
			{
				Player player;
				PositionData position;
				ZNetPeer peer;
				if ((Object)(object)Player.m_localPlayer != (Object)null && Player.m_localPlayer.GetPlayerID() == playerId)
				{
					((Character)Player.m_localPlayer).Message((MessageType)1, message, 0, (Sprite)null);
				}
				else if (TryResolvePlayerState(playerId, out player, out position, out peer) && peer != null)
				{
					ZRoutedRpc.instance.InvokeRoutedRPC(peer.m_uid, "ShowMessage", new object[2] { 1, message });
				}
			}
		}

		private static void SendPlayerPopup(long playerId, string message)
		{
			if (string.IsNullOrWhiteSpace(message) || (Object)(object)ZNet.instance == (Object)null || ZRoutedRpc.instance == null)
			{
				return;
			}
			if ((Object)(object)Player.m_localPlayer != (Object)null && Player.m_localPlayer.GetPlayerID() == playerId)
			{
				try
				{
					MessageHud instance = MessageHud.instance;
					if (instance != null)
					{
						instance.ShowMessage((MessageType)2, message, 0, (Sprite)null, false);
					}
					return;
				}
				catch (Exception ex)
				{
					Plugin.Debug("Could not display the arena boundary popup: " + ex.Message);
					return;
				}
			}
			if (TryResolvePlayerState(playerId, out var _, out var _, out var peer) && peer != null)
			{
				ZRoutedRpc.instance.InvokeRoutedRPC(peer.m_uid, "ShowMessage", new object[2] { 2, message });
			}
		}

		private static void SendGlobalMessage(string message)
		{
			if (!string.IsNullOrWhiteSpace(message) && ZRoutedRpc.instance != null)
			{
				ZRoutedRpc.instance.InvokeRoutedRPC(ZRoutedRpc.Everybody, "ShowMessage", new object[2] { 1, message });
			}
		}

		private static BiomeTier GetWorldUnlockedBiome()
		{
			ZoneSystem instance = ZoneSystem.instance;
			if ((Object)(object)instance == (Object)null)
			{
				return BiomeTier.Meadows;
			}
			if (instance.GetGlobalKey("defeated_fader"))
			{
				return BiomeTier.DeepNorth;
			}
			if (instance.GetGlobalKey("defeated_queen"))
			{
				return BiomeTier.Ashlands;
			}
			if (instance.GetGlobalKey((GlobalKeys)35))
			{
				return BiomeTier.Mistlands;
			}
			if (instance.GetGlobalKey((GlobalKeys)34))
			{
				return BiomeTier.Plains;
			}
			if (instance.GetGlobalKey((GlobalKeys)37))
			{
				return BiomeTier.Mountain;
			}
			if (instance.GetGlobalKey((GlobalKeys)36))
			{
				return BiomeTier.Swamp;
			}
			if (instance.GetGlobalKey((GlobalKeys)33))
			{
				return BiomeTier.BlackForest;
			}
			return BiomeTier.Meadows;
		}

		internal static void TickOnMainThread()
		{
			if (!_initialized || (Object)(object)ZNet.instance == (Object)null)
			{
				return;
			}
			ArenaRpc.Register();
			long worldUID = ZNet.instance.GetWorldUID();
			if (worldUID != 0L && worldUID != _loadedWorldUid)
			{
				LoadWorld(worldUID);
			}
			if (ZNet.instance.IsServer() && _loadedWorldUid != 0L)
			{
				DetectFloorEntryAndBoundary();
				_engine.Tick(DateTime.UtcNow);
				ReconcileArenaEnemies();
				ProcessEngineEffects();
				RetryPendingRestores();
				DateTime utcNow = DateTime.UtcNow;
				if (utcNow >= _nextProtectedWildlifeSweepUtc)
				{
					_nextProtectedWildlifeSweepUtc = utcNow.AddSeconds(1.0);
					RemoveProtectedWildlife();
				}
			}
			if (_loadedWorldUid != 0L)
			{
				ReportClientCombatStartArrival();
			}
			if (DateTime.UtcNow >= _nextCollisionRefreshUtc)
			{
				_nextCollisionRefreshUtc = DateTime.UtcNow.AddSeconds(1.0);
				RefreshParticipantCollisions();
			}
		}

		internal static IList<string> SpawnEncounter(EncounterDefinition encounter)
		{
			return SpawnEncounter(ArenaRegistry.GetArenaSnapshot().Select(delegate(ArenaDefinition arena)
			{
				ArenaRegistry.TryGetActiveSession(arena.ArenaId, out var session);
				return session;
			}).FirstOrDefault((ArenaSession active) => active != null && active.Phase == SessionPhase.Fighting && active.EncounterIndex == encounter?.Sequence), encounter);
		}

		internal static IList<string> SpawnEncounter(ArenaSession session, EncounterDefinition encounter)
		{
			//IL_01d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01db: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ff: Unknown result type (might be due to invalid IL or missing references)
			List<string> list = new List<string>();
			if (!IsAuthoritativeServer() || session == null || encounter == null || !ArenaRegistry.TryGetArena(session.ArenaId, out var definition) || definition.Markers?.EnemySpawnPositions == null || definition.Markers.EnemySpawnPositions.Count == 0 || (Object)(object)ZNetScene.instance == (Object)null)
			{
				return list;
			}
			CreatureDefinition creatureDefinition = new ChallengeCatalog().GetRoster().FirstOrDefault((CreatureDefinition candidate) => string.Equals(candidate.CreatureKey, encounter.CreatureKey, StringComparison.OrdinalIgnoreCase));
			GameObject val = ((creatureDefinition == null) ? null : ZNetScene.instance.GetPrefab(creatureDefinition.PrefabName));
			GameObject val2 = ((creatureDefinition == null || string.IsNullOrWhiteSpace(creatureDefinition.SecondaryPrefabName)) ? null : ZNetScene.instance.GetPrefab(creatureDefinition.SecondaryPrefabName));
			if ((Object)(object)val == (Object)null || (!string.IsNullOrWhiteSpace(creatureDefinition?.SecondaryPrefabName) && (Object)(object)val2 == (Object)null))
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogError((object)("Arena creature prefab is unavailable: " + encounter.CreatureKey));
				}
				return list;
			}
			GameObject[] array = (GameObject[])(object)((!((Object)(object)val2 == (Object)null)) ? new GameObject[2] { val, val2 } : new GameObject[1] { val });
			int num = Math.Max(1, Math.Min(10, encounter.Quantity));
			int value;
			int previousMarker = (LastSpawnMarkerBySessionId.TryGetValue(session.SessionId, out value) ? value : (-1));
			IList<int> list2 = ArenaSpawnSelectionPolicy.BuildOrder(definition.Markers.EnemySpawnPositions.Count, num * array.Length, NextSpawnSeed(), previousMarker);
			int num2 = 0;
			for (int num3 = 0; num3 < num; num3++)
			{
				List<string> list3 = new List<string>(array.Length);
				bool flag = true;
				for (int num4 = 0; num4 < array.Length; num4++)
				{
					int num5 = list2[num2++];
					Vector3 val3 = ToVector3(definition.Markers.EnemySpawnPositions[num5]);
					GameObject val4 = Object.Instantiate<GameObject>(array[num4], val3, Quaternion.identity);
					Character val5 = (((Object)(object)val4 == (Object)null) ? null : val4.GetComponent<Character>());
					ZNetView val6 = (((Object)(object)val4 == (Object)null) ? null : val4.GetComponent<ZNetView>());
					if ((Object)(object)val5 == (Object)null || (Object)(object)val6 == (Object)null || !val6.IsValid())
					{
						if ((Object)(object)val4 != (Object)null)
						{
							Object.Destroy((Object)(object)val4);
						}
						flag = false;
						break;
					}
					string text = Guid.NewGuid().ToString("D").ToLowerInvariant();
					val5.SetLevel((int)(encounter.Stars + 1));
					CharacterDrop component = val4.GetComponent<CharacterDrop>();
					if (component != null)
					{
						component.SetDropsEnabled(false);
					}
					ZDO zDO = val6.GetZDO();
					zDO.Set("arenaguard.arena_id", session.ArenaId);
					zDO.Set("arenaguard.session_id", session.SessionId);
					zDO.Set("arenaguard.enemy_id", text);
					Enemies[text] = new ArenaEnemyHandle
					{
						EnemyId = text,
						ArenaId = session.ArenaId,
						SessionId = session.SessionId,
						Character = val5,
						SpawnPosition = val3,
						SpawnMarkerIndex = num5
					};
					list3.Add(text);
					ArenaRuleContext.CacheEnemyArenaId(val5, session.ArenaId);
					AggroArenaEnemy(val5, session.Request?.PlayerId ?? 0);
				}
				if (!flag)
				{
					foreach (string item in list3)
					{
						if (Enemies.TryGetValue(item, out var value2))
						{
							DestroyEnemy(value2);
						}
					}
				}
				else
				{
					list.Add(list3[0]);
				}
			}
			if (num2 > 0)
			{
				LastSpawnMarkerBySessionId[session.SessionId] = list2[num2 - 1];
			}
			return list;
		}

		private static int NextSpawnSeed()
		{
			lock (SpawnRandom)
			{
				return SpawnRandom.Next();
			}
		}

		internal static void DespawnSessionEnemies(string sessionId)
		{
			DespawnSessionEnemies(sessionId, null);
		}

		private static void RemoveProtectedWildlife()
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Invalid comparison between Unknown and I4
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			ProtectedWildlifeCharacters.Clear();
			foreach (Character allCharacter in Character.GetAllCharacters())
			{
				if (!((Object)(object)allCharacter == (Object)null) && ArenaWildlifePolicy.ShouldRemoveCharacter(ArenaRegistry.FindProtectedArena(ToPositionData(((Component)allCharacter).transform.position)) != null, isArenaEnemy: !string.IsNullOrWhiteSpace(ReadZdo(allCharacter, "arenaguard.arena_id")), isPassiveWildlife: allCharacter.GetBaseAI() is AnimalAI || (int)allCharacter.GetFaction() == 1, isPlayer: allCharacter is Player, isTamed: allCharacter.IsTamed(), isArenaMaster: ArenaWorldObjects.IsChallengeHost(allCharacter)))
				{
					ProtectedWildlifeCharacters.Add(allCharacter);
				}
			}
			ProtectedWildlifeBirds.Clear();
			foreach (IMonoUpdater instance in RandomFlyingBird.Instances)
			{
				RandomFlyingBird val = (RandomFlyingBird)(object)((instance is RandomFlyingBird) ? instance : null);
				if ((Object)(object)val != (Object)null && ArenaRegistry.FindProtectedArena(ToPositionData(((Component)val).transform.position)) != null)
				{
					ProtectedWildlifeBirds.Add(val);
				}
			}
			foreach (Character protectedWildlifeCharacter in ProtectedWildlifeCharacters)
			{
				DestroyProtectedWildlife(((Component)protectedWildlifeCharacter).gameObject);
			}
			foreach (RandomFlyingBird protectedWildlifeBird in ProtectedWildlifeBirds)
			{
				if ((Object)(object)protectedWildlifeBird != (Object)null)
				{
					DestroyProtectedWildlife(((Component)protectedWildlifeBird).gameObject);
				}
			}
		}

		private static void DestroyProtectedWildlife(GameObject wildlife)
		{
			if ((Object)(object)wildlife == (Object)null)
			{
				return;
			}
			ZNetView component = wildlife.GetComponent<ZNetView>();
			if ((Object)(object)component != (Object)null && component.IsValid())
			{
				component.ClaimOwnership();
				ZNetScene instance = ZNetScene.instance;
				if (instance != null)
				{
					instance.Destroy(wildlife);
				}
			}
			else
			{
				Object.Destroy((Object)(object)wildlife);
			}
		}

		private static void DespawnSessionEnemies(string sessionId, string arenaId)
		{
			//IL_0182: Unknown result type (might be due to invalid IL or missing references)
			if (string.IsNullOrWhiteSpace(sessionId))
			{
				return;
			}
			LastSpawnMarkerBySessionId.Remove(sessionId);
			HashSet<Character> hashSet = new HashSet<Character>();
			foreach (ArenaEnemyHandle item in Enemies.Values.Where((ArenaEnemyHandle candidate) => string.Equals(candidate.SessionId, sessionId, StringComparison.Ordinal)).ToList())
			{
				Enemies.Remove(item.EnemyId);
				if ((Object)(object)item.Character != (Object)null)
				{
					hashSet.Add(item.Character);
				}
			}
			foreach (Character item2 in Character.GetAllCharacters().ToList())
			{
				if ((Object)(object)item2 != (Object)null && string.Equals(ReadZdo(item2, "arenaguard.session_id"), sessionId, StringComparison.Ordinal))
				{
					hashSet.Add(item2);
				}
			}
			if (!string.IsNullOrWhiteSpace(arenaId) && ArenaRegistry.TryGetArena(arenaId, out var definition))
			{
				foreach (Character item3 in Character.GetAllCharacters().ToList())
				{
					if (!((Object)(object)item3 == (Object)null) && !(item3 is Player) && !item3.IsTamed() && !ArenaWorldObjects.IsChallengeHost(item3) && Near(ToPositionData(((Component)item3).transform.position), definition.CorePosition, definition.ProtectedRadius))
					{
						hashSet.Add(item3);
					}
				}
			}
			foreach (Character item4 in hashSet)
			{
				DestroyArenaCharacter(item4);
			}
		}

		internal static bool MoveToStaging(long playerId)
		{
			return MovePlayerToArenaMarker(playerId, (ArenaDefinition arena) => arena.Markers?.StagingPosition);
		}

		internal static bool MoveToSpectatorArea(long playerId)
		{
			SetRole(playerId, ArenaRole.Spectator);
			return MovePlayerToArenaMarker(playerId, (ArenaDefinition arena) => arena.Markers?.StagingPosition);
		}

		private static bool OpenLocalFoodPreparation(ArenaClientSnapshot arena)
		{
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null || arena == null)
			{
				return false;
			}
			List<string> list = LoadPreferredFoodKeys(localPlayer.GetPlayerID());
			foreach (Food food in localPlayer.GetFoods())
			{
				if (!string.IsNullOrWhiteSpace(food?.m_name) && !list.Contains(food.m_name))
				{
					list.Add(food.m_name);
				}
			}
			return ArenaUi.OpenFoodPreparation(arena.ArenaId, GetArenaFoods(localPlayer, requireKnown: true), list, Math.Max(1, arena.CountdownSeconds));
		}

		private static bool ConfirmLocalFoodPreparation(IList<string> selectedPrefabNames)
		{
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null)
			{
				return false;
			}
			long playerId = localPlayer.GetPlayerID();
			ArenaClientSnapshot arenaClientSnapshot = ClientArenaSnapshots.Values.FirstOrDefault((ArenaClientSnapshot snapshot) => snapshot != null && snapshot.CombatantPlayerId == playerId && snapshot.Phase == SessionPhase.Staging && !snapshot.PreparationComplete);
			if (arenaClientSnapshot == null || ClientPreparations.ContainsKey(arenaClientSnapshot.ArenaId))
			{
				((Character)localPlayer).Message((MessageType)2, "The arena is not waiting for food preparation.", 0, (Sprite)null);
				return false;
			}
			List<ArenaFoodDefinition> list = GetArenaFoods(localPlayer, requireKnown: true).ToList();
			HashSet<string> eligiblePrefabNames = new HashSet<string>(list.Select((ArenaFoodDefinition food) => food.PrefabName), StringComparer.Ordinal);
			if (!ArenaFoodSelectionPolicy.IsValid(selectedPrefabNames, eligiblePrefabNames))
			{
				((Character)localPlayer).Message((MessageType)2, "Choose exactly three distinct foods your character has discovered.", 0, (Sprite)null);
				return false;
			}
			PlayerResourceSnapshot playerResourceSnapshot = CaptureResources(playerId);
			if (playerResourceSnapshot == null)
			{
				return false;
			}
			playerResourceSnapshot.ArenaFoodPrefabNames = selectedPrefabNames.Select((string value) => value.Trim()).ToList();
			if (!ApplyTemporaryArenaFood(localPlayer, playerResourceSnapshot.ArenaFoodPrefabNames, list))
			{
				RestoreResources(playerId, SessionOutcome.RuntimeError);
				((Character)localPlayer).Message((MessageType)2, "Arena food could not be applied. Try again.", 0, (Sprite)null);
				return false;
			}
			SavePreferredFoodKeys(playerId, playerResourceSnapshot.ArenaFoodPrefabNames);
			ClientPreparations[arenaClientSnapshot.ArenaId] = new ClientPreparationState
			{
				Snapshot = playerResourceSnapshot,
				SubmittedUtc = DateTime.UtcNow,
				SubmissionAttempts = 1,
				Accepted = false
			};
			ArenaRpc.SubmitResourceSnapshot(playerResourceSnapshot);
			return true;
		}

		private static void RollBackLocalPreparation(string arenaId, string message)
		{
			if (!ClientPreparations.TryGetValue(arenaId, out var value))
			{
				return;
			}
			ClientPreparations.Remove(arenaId);
			ClientFoodPrompts.Remove(arenaId);
			if (value?.Snapshot != null)
			{
				ResourceSnapshots[value.Snapshot.PlayerId] = value.Snapshot;
				RestoreResources(value.Snapshot.PlayerId, SessionOutcome.RuntimeError);
			}
			ArenaUi.CloseFoodPreparation(arenaId);
			if (!string.IsNullOrWhiteSpace(message))
			{
				Player localPlayer = Player.m_localPlayer;
				if (localPlayer != null)
				{
					((Character)localPlayer).Message((MessageType)2, message, 0, (Sprite)null);
				}
			}
		}

		private static IList<ArenaFoodDefinition> GetArenaFoods(Player player, bool requireKnown)
		{
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Invalid comparison between Unknown and I4
			if ((Object)(object)ObjectDB.instance == (Object)null)
			{
				return new List<ArenaFoodDefinition>();
			}
			Dictionary<string, ArenaFoodDefinition> dictionary = new Dictionary<string, ArenaFoodDefinition>(StringComparer.Ordinal);
			foreach (GameObject item in ObjectDB.instance.m_items)
			{
				ItemData val = ((item != null) ? item.GetComponent<ItemDrop>() : null)?.m_itemData;
				if (val?.m_shared != null && (int)val.m_shared.m_itemType == 2 && !(val.m_shared.m_foodBurnTime <= 0f) && (!(val.m_shared.m_food <= 0f) || !(val.m_shared.m_foodStamina <= 0f) || !(val.m_shared.m_foodEitr <= 0f)) && (!requireKnown || (!((Object)(object)player == (Object)null) && player.IsKnownMaterial(val.m_shared.m_name))))
				{
					string name = ((Object)item).name;
					if (!string.IsNullOrWhiteSpace(name) && !dictionary.ContainsKey(name))
					{
						string text = ((Localization.instance == null) ? val.m_shared.m_name : Localization.instance.Localize(val.m_shared.m_name));
						dictionary[name] = new ArenaFoodDefinition
						{
							PrefabName = name,
							DisplayName = (string.IsNullOrWhiteSpace(text) ? name : text),
							Health = val.m_shared.m_food,
							Stamina = val.m_shared.m_foodStamina,
							Eitr = val.m_shared.m_foodEitr,
							DurationSeconds = val.m_shared.m_foodBurnTime
						};
					}
				}
			}
			return dictionary.Values.OrderBy<ArenaFoodDefinition, string>((ArenaFoodDefinition food) => food.DisplayName, StringComparer.OrdinalIgnoreCase).ToList();
		}

		private static bool ApplyTemporaryArenaFood(Player player, IList<string> selectedPrefabNames, IList<ArenaFoodDefinition> knownFoods)
		{
			if ((Object)(object)player == (Object)null || selectedPrefabNames == null || knownFoods == null)
			{
				return false;
			}
			Dictionary<string, ArenaFoodDefinition> dictionary = knownFoods.ToDictionary<ArenaFoodDefinition, string>((ArenaFoodDefinition food) => food.PrefabName, StringComparer.Ordinal);
			List<FoodStateSnapshot> list = new List<FoodStateSnapshot>();
			foreach (string selectedPrefabName in selectedPrefabNames)
			{
				if (!dictionary.TryGetValue(selectedPrefabName, out var value))
				{
					return false;
				}
				list.Add(new FoodStateSnapshot
				{
					ItemPrefabName = value.PrefabName,
					RemainingSeconds = value.DurationSeconds,
					Health = value.Health,
					Stamina = value.Stamina,
					Eitr = value.Eitr
				});
			}
			RestoreFoods(player, list);
			RefreshFoodStats(player);
			SEMan sEMan = ((Character)player).GetSEMan();
			sEMan.RemoveStatusEffect(SEMan.s_statusEffectRested, true);
			StatusEffect val = sEMan.AddStatusEffect(SEMan.s_statusEffectRested, true, 0, 0f);
			val = val ?? sEMan.GetStatusEffect(SEMan.s_statusEffectRested);
			if ((Object)(object)val == (Object)null)
			{
				return false;
			}
			val.ResetTime();
			val.m_ttl = 0f;
			((Character)player).SetHealth(((Character)player).GetMaxHealth());
			((Character)player).AddStamina(((Character)player).GetMaxStamina());
			((Character)player).AddEitr(((Character)player).GetMaxEitr());
			return true;
		}

		private static List<string> LoadPreferredFoodKeys(long playerId)
		{
			return (from item in PlayerPrefs.GetString("ArenaGuard.FoodLoadout." + playerId, string.Empty).Split(new char[1] { '|' }, StringSplitOptions.RemoveEmptyEntries)
				select item.Trim() into item
				where item.Length > 0
				select item).Distinct<string>(StringComparer.Ordinal).Take(3).ToList();
		}

		private static void SavePreferredFoodKeys(long playerId, IEnumerable<string> prefabNames)
		{
			PlayerPrefs.SetString("ArenaGuard.FoodLoadout." + playerId, string.Join("|", prefabNames ?? Enumerable.Empty<string>()));
			PlayerPrefs.Save();
		}

		internal static PlayerResourceSnapshot CaptureResources(long playerId)
		{
			//IL_0129: Unknown result type (might be due to invalid IL or missing references)
			//IL_0130: Invalid comparison between Unknown and I4
			//IL_0139: Unknown result type (might be due to invalid IL or missing references)
			//IL_0140: Invalid comparison between Unknown and I4
			Player val = FindPlayer(playerId);
			if ((Object)(object)val == (Object)null)
			{
				return null;
			}
			PlayerResourceSnapshot playerResourceSnapshot = new PlayerResourceSnapshot
			{
				PlayerId = playerId,
				Foods = (from food in val.GetFoods()
					select new FoodStateSnapshot
					{
						ItemPrefabName = food.m_name,
						RemainingSeconds = food.m_time,
						Health = food.m_health,
						Stamina = food.m_stamina,
						Eitr = food.m_eitr
					}).ToList(),
				RestedRemainingSeconds = GetRestedRemainingSeconds(val),
				ArenaFoodPrefabNames = new List<string>(),
				AllowedConsumableCounts = new Dictionary<string, int>(StringComparer.Ordinal),
				AmmunitionCounts = new Dictionary<string, int>(StringComparer.Ordinal),
				EquipmentDurabilityBySlot = new Dictionary<string, float>(StringComparer.Ordinal),
				CapturedUtc = DateTime.UtcNow
			};
			int num = 0;
			foreach (ItemData allItem in ((Humanoid)val).GetInventory().GetAllItems())
			{
				if (allItem?.m_shared != null)
				{
					string text = (((Object)(object)allItem.m_dropPrefab == (Object)null) ? allItem.m_shared.m_name : ((Object)allItem.m_dropPrefab).name);
					if (ArenaRuleContext.IsRecoveryConsumable(allItem))
					{
						AddCount(playerResourceSnapshot.AllowedConsumableCounts, text, allItem.m_stack);
					}
					if ((int)allItem.m_shared.m_itemType == 9 || (int)allItem.m_shared.m_itemType == 23)
					{
						AddCount(playerResourceSnapshot.AmmunitionCounts, text, allItem.m_stack);
					}
					if (allItem.m_equipped && allItem.m_shared.m_useDurability)
					{
						playerResourceSnapshot.EquipmentDurabilityBySlot[num++ + ":" + text] = allItem.m_durability;
					}
				}
			}
			ResourceSnapshots[playerId] = playerResourceSnapshot;
			return playerResourceSnapshot;
		}

		internal static bool RestoreResources(long playerId, SessionOutcome outcome)
		{
			Player val = FindPlayer(playerId);
			if ((Object)(object)val == (Object)null || !ResourceSnapshots.TryGetValue(playerId, out var value))
			{
				return false;
			}
			RestoreStackCounts(((Humanoid)val).GetInventory(), value.AllowedConsumableCounts);
			RestoreStackCounts(((Humanoid)val).GetInventory(), value.AmmunitionCounts);
			RestoreDurability(((Humanoid)val).GetInventory(), value.EquipmentDurabilityBySlot);
			RestoreFoods(val, value.Foods);
			RefreshFoodStats(val);
			((Character)val).GetSEMan().RemoveStatusEffect(SEMan.s_statusEffectRested, true);
			RestoreRested(val, value.RestedRemainingSeconds);
			((Character)val).SetHealth(((Character)val).GetMaxHealth());
			((Character)val).AddStamina(((Character)val).GetMaxStamina());
			((Character)val).AddEitr(((Character)val).GetMaxEitr());
			ResourceSnapshots.Remove(playerId);
			return true;
		}

		internal static void RepositionEscapedOrStuckEnemies(string sessionId)
		{
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0145: Unknown result type (might be due to invalid IL or missing references)
			//IL_014a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0153: Unknown result type (might be due to invalid IL or missing references)
			//IL_015b: Unknown result type (might be due to invalid IL or missing references)
			//IL_015d: Unknown result type (might be due to invalid IL or missing references)
			foreach (ArenaEnemyHandle item in Enemies.Values.Where((ArenaEnemyHandle candidate) => string.Equals(candidate.SessionId, sessionId, StringComparison.Ordinal)).ToList())
			{
				Character character = item.Character;
				if ((Object)(object)character == (Object)null || character.IsDead() || !ArenaRegistry.TryGetArena(item.ArenaId, out var definition) || definition.Markers?.EnemySpawnPositions == null || definition.Markers.EnemySpawnPositions.Count == 0)
				{
					continue;
				}
				Vector3 position = ((Component)character).transform.position;
				float num = position.x - definition.CorePosition.X;
				float num2 = position.z - definition.CorePosition.Z;
				if (num * num + num2 * num2 > definition.CombatRadius * definition.CombatRadius)
				{
					int num3 = ArenaSpawnSelectionPolicy.BuildOrder(definition.Markers.EnemySpawnPositions.Count, 1, NextSpawnSeed(), item.SpawnMarkerIndex)[0];
					Vector3 val = ToVector3(definition.Markers.EnemySpawnPositions[num3]);
					((Component)character).transform.position = val;
					item.SpawnPosition = val;
					item.SpawnMarkerIndex = num3;
					if (ArenaRegistry.TryGetActiveSession(item.ArenaId, out var session))
					{
						AggroArenaEnemy(character, session.Request?.PlayerId ?? 0);
					}
				}
			}
		}

		private static void AggroArenaEnemy(Character enemy, long combatantPlayerId)
		{
			BaseAI obj = ((enemy != null) ? enemy.GetBaseAI() : null);
			MonsterAI val = (MonsterAI)(object)((obj is MonsterAI) ? obj : null);
			if ((Object)(object)val == (Object)null)
			{
				return;
			}
			try
			{
				MonsterAiWakeupMethod?.Invoke(val, null);
				((BaseAI)val).SetHuntPlayer(true);
				((BaseAI)val).Alert();
				TryResolvePlayerState(combatantPlayerId, out var player, out var _, out var _);
				if ((Object)(object)player != (Object)null)
				{
					MonsterAiSetTargetMethod?.Invoke(val, new object[1] { player });
				}
			}
			catch (Exception ex)
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogWarning((object)("Could not immediately aggro arena enemy " + ((Object)enemy).name + " on combatant " + combatantPlayerId + ": " + ex.Message));
				}
			}
		}

		internal static void SetRole(long playerId, ArenaRole role)
		{
			if (role == ArenaRole.Visitor)
			{
				Roles.Remove(playerId);
			}
			else
			{
				Roles[playerId] = role;
			}
		}

		internal static ArenaRole ResolveRole(long playerId)
		{
			if (!Roles.TryGetValue(playerId, out var value))
			{
				return ArenaRole.Visitor;
			}
			return value;
		}

		internal static void Shutdown()
		{
			PrepareForWorldShutdown();
			foreach (ArenaEnemyHandle item in Enemies.Values.ToList())
			{
				DestroyEnemy(item);
			}
			Enemies.Clear();
			LastSpawnMarkerBySessionId.Clear();
			Roles.Clear();
			ResourceSnapshots.Clear();
			PendingRestores.Clear();
			ClientFoodPrompts.Clear();
			ClientPreparations.Clear();
			ClientQueuePromptSessions.Clear();
			ClientRestoredSnapshots.Clear();
			ClientArenaSnapshots.Clear();
			_clientAdminsMayModifyTerrain = false;
			_clientAdminsMayBuild = false;
			_clientAdminsMayPickupDroppedItems = false;
			ClientCombatStartArrivalRetryUtc.Clear();
			StaleClientCombatStartArrivalArenaIds.Clear();
			CombatStartMoveRetryUtc.Clear();
			CombatBoundaryStates.Clear();
			ActiveCombatantIds.Clear();
			AwaitingCombatStartIds.Clear();
			StaleCombatantIds.Clear();
			_nextClientCombatStartArrivalCheckTime = 0f;
			ArenaRpc.Shutdown();
			ArenaUi.CloseArenaUi();
			ArenaWorldObjects.PlacementRequested = null;
			ArenaWorldObjects.CoreRemovalRequested = null;
			ArenaWorldObjects.CoreActivated = null;
			ArenaWorldObjects.AdminMarkerRequested = null;
			ArenaWorldObjects.AdminMarkerRemovalRequested = null;
			ArenaWorldObjects.ArenaAtPositionResolver = null;
			ArenaWorldObjects.ArenaDefinitionResolver = null;
			ArenaTeleporters.GateTravelRequested = null;
			ArenaTeleporters.GateConfigurationRequested = null;
			ArenaUi.ChallengeRequested = null;
			ArenaUi.QueueAccepted = null;
			ArenaUi.ForfeitRequested = null;
			ArenaUi.LeaderboardRequested = null;
			ArenaUi.AdminMutationRequested = null;
			ArenaUi.AdminPermissionResolver = null;
			ArenaUi.CreatureListResolver = null;
			ArenaUi.FoodPreparationConfirmed = null;
			ArenaUi.FoodPreparationCancelled = null;
			ArenaRegistry.Clear();
			ArenaStore.Clear();
			_engine = null;
			_catalog = null;
			_loadedWorldUid = 0L;
			_initialized = false;
			ArenaRuleContext.Reset();
		}

		internal static void PrepareForWorldShutdown()
		{
			if (_initialized && (Object)(object)ZNet.instance != (Object)null && ZNet.instance.IsServer() && _loadedWorldUid != 0L)
			{
				SaveWorldState();
			}
		}

		private static void ReportLethalDamage(long playerId)
		{
			if ((Object)(object)ZNet.instance != (Object)null && ZNet.instance.IsServer())
			{
				_engine?.ReportLethalDamage(playerId);
				ProcessEngineEffects();
			}
			else
			{
				ArenaRpc.ReportLethalDamage();
			}
		}

		private static void ReportArenaEnemyDeath(Character character)
		{
			string text = ReadZdo(character, "arenaguard.enemy_id");
			string sessionId = ReadZdo(character, "arenaguard.session_id");
			ArenaRuleContext.ForgetEnemy(character);
			if (!string.IsNullOrEmpty(text))
			{
				Enemies.Remove(text);
			}
			if (!string.IsNullOrEmpty(sessionId) && !Enemies.Values.Any((ArenaEnemyHandle handle) => string.Equals(handle.SessionId, sessionId, StringComparison.Ordinal)))
			{
				_engine?.ReportEncounterCleared(sessionId);
				ProcessEngineEffects();
			}
		}

		private static void RegisterArenaSummon(Character owner, GameObject spawned)
		{
			//IL_0164: Unknown result type (might be due to invalid IL or missing references)
			//IL_0169: Unknown result type (might be due to invalid IL or missing references)
			if (!IsAuthoritativeServer() || (Object)(object)owner == (Object)null || (Object)(object)spawned == (Object)null)
			{
				return;
			}
			string enemyArenaId = ArenaRuleContext.GetEnemyArenaId(owner);
			string text = ReadZdo(owner, "arenaguard.session_id");
			if (string.IsNullOrWhiteSpace(enemyArenaId) || string.IsNullOrWhiteSpace(text))
			{
				return;
			}
			Character val = spawned.GetComponent<Character>() ?? spawned.GetComponentInChildren<Character>();
			ZNetView val2 = (((Object)(object)val == (Object)null) ? null : ((Component)val).GetComponent<ZNetView>());
			if ((Object)(object)val == (Object)null || (Object)(object)val2 == (Object)null || !val2.IsValid())
			{
				return;
			}
			ArenaSession session = null;
			if (_engine == null || !_engine.TryGetActiveSession(enemyArenaId, out session) || !string.Equals(session.SessionId, text, StringComparison.Ordinal) || session.Phase != SessionPhase.Fighting)
			{
				DestroyArenaCharacter(val);
				return;
			}
			ZDO zDO = val2.GetZDO();
			string text2 = zDO.GetString("arenaguard.enemy_id", string.Empty);
			if (string.IsNullOrWhiteSpace(text2))
			{
				text2 = Guid.NewGuid().ToString("D").ToLowerInvariant();
				zDO.Set("arenaguard.arena_id", enemyArenaId);
				zDO.Set("arenaguard.session_id", text);
				zDO.Set("arenaguard.enemy_id", text2);
			}
			CharacterDrop component = ((Component)val).GetComponent<CharacterDrop>();
			if (component != null)
			{
				component.SetDropsEnabled(false);
			}
			Enemies[text2] = new ArenaEnemyHandle
			{
				EnemyId = text2,
				ArenaId = enemyArenaId,
				SessionId = text,
				Character = val,
				SpawnPosition = ((Component)val).transform.position,
				SpawnMarkerIndex = -1
			};
			ArenaRuleContext.CacheEnemyArenaId(val, enemyArenaId);
			AggroArenaEnemy(val, session.Request?.PlayerId ?? 0);
			Plugin.Debug("Registered arena summon " + ((Object)val).name + " for session " + text + ".");
		}

		private static string ResolveEnemyArenaId(Character character)
		{
			return ReadZdo(character, "arenaguard.arena_id");
		}

		private static long ResolveCombatant(string arenaId)
		{
			if (!ArenaRegistry.TryGetActiveSession(arenaId, out var session) || session.Request == null)
			{
				return 0L;
			}
			return session.Request.PlayerId;
		}

		private static bool MovePlayerToArenaMarker(long playerId, Func<ArenaDefinition, PositionData?> marker)
		{
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			Player player = FindPlayer(playerId);
			if ((Object)(object)player == (Object)null)
			{
				return false;
			}
			ArenaDefinition arenaDefinition = ArenaRegistry.GetArenaSnapshot().FirstOrDefault(delegate(ArenaDefinition candidate)
			{
				//IL_0014: Unknown result type (might be due to invalid IL or missing references)
				if (candidate != null)
				{
					if (!(candidate.ArenaId == ArenaRegistry.FindProtectedArena(ToPositionData(((Component)player).transform.position))?.ArenaId))
					{
						if (ArenaRegistry.TryGetActiveSession(candidate.ArenaId, out var session))
						{
							ChallengeRequest request = session.Request;
							if (request == null)
							{
								return false;
							}
							return request.PlayerId == playerId;
						}
						return false;
					}
					return true;
				}
				return false;
			});
			PositionData? positionData = ((arenaDefinition == null) ? ((PositionData?)null) : marker(arenaDefinition));
			if (positionData.HasValue)
			{
				return ((Character)player).TeleportTo(ToVector3(positionData.Value), ((Component)player).transform.rotation, false);
			}
			return false;
		}

		private static Player FindPlayer(long playerId)
		{
			return ((IEnumerable<Player>)Player.GetAllPlayers()).FirstOrDefault((Func<Player, bool>)((Player player) => (Object)(object)player != (Object)null && player.GetPlayerID() == playerId));
		}

		private static bool TryResolvePlayerState(long playerId, out Player player, out PositionData position, out ZNetPeer peer)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_0140: Unknown result type (might be due to invalid IL or missing references)
			//IL_0182: Unknown result type (might be due to invalid IL or missing references)
			//IL_0174: Unknown result type (might be due to invalid IL or missing references)
			player = FindPlayer(playerId);
			peer = null;
			if ((Object)(object)player != (Object)null)
			{
				position = ToPositionData(((Component)player).transform.position);
				ZDOID playerZdoId = ((Character)player).GetZDOID();
				if ((Object)(object)ZNet.instance != (Object)null)
				{
					peer = ((IEnumerable<ZNetPeer>)ZNet.instance.GetConnectedPeers()).FirstOrDefault((Func<ZNetPeer, bool>)((ZNetPeer candidate) => candidate != null && candidate.m_characterID == playerZdoId));
				}
				return true;
			}
			position = default(PositionData);
			ZNet instance = ZNet.instance;
			ZDOMan instance2 = ZDOMan.instance;
			ZNetScene instance3 = ZNetScene.instance;
			if (playerId <= 0 || (Object)(object)instance == (Object)null || instance2 == null || (Object)(object)instance3 == (Object)null)
			{
				return false;
			}
			foreach (ZNetPeer connectedPeer in instance.GetConnectedPeers())
			{
				if (connectedPeer == null || connectedPeer.m_characterID == ZDOID.None)
				{
					continue;
				}
				ZDO zDO = instance2.GetZDO(connectedPeer.m_characterID);
				if (zDO != null && zDO.GetOwner() == connectedPeer.m_uid && zDO.GetLong(ZDOVars.s_playerID, 0L) == playerId)
				{
					GameObject prefab = instance3.GetPrefab(zDO.GetPrefab());
					if (!((Object)(object)prefab == (Object)null) && !((Object)(object)prefab.GetComponent<Player>() == (Object)null))
					{
						GameObject val = instance3.FindInstance(connectedPeer.m_characterID);
						player = (((Object)(object)val == (Object)null) ? null : val.GetComponent<Player>());
						position = (((Object)(object)player == (Object)null) ? ToPositionData(zDO.GetPosition()) : ToPositionData(((Component)player).transform.position));
						peer = connectedPeer;
						return true;
					}
				}
			}
			return false;
		}

		private static bool IsLocalAdministrator()
		{
			if (SynchronizationManager.Instance == null || !SynchronizationManager.Instance.PlayerIsAdmin)
			{
				if ((Object)(object)ZNet.instance != (Object)null)
				{
					return ZNet.instance.LocalPlayerIsAdminOrHost();
				}
				return false;
			}
			return true;
		}

		private static bool IsAdministrator(Player player)
		{
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)player == (Object)null || (Object)(object)ZNet.instance == (Object)null)
			{
				return false;
			}
			if ((Object)(object)player == (Object)(object)Player.m_localPlayer)
			{
				return IsLocalAdministrator();
			}
			ZDOID zDOID = ((Character)player).GetZDOID();
			foreach (PlayerInfo player2 in ZNet.instance.GetPlayerList())
			{
				if (player2.m_characterID == zDOID)
				{
					return ZNet.instance.PlayerIsAdmin(player2.m_userInfo.m_id);
				}
			}
			return false;
		}

		private static bool IsAuthoritativeServer()
		{
			if ((Object)(object)ZNet.instance != (Object)null)
			{
				return ZNet.instance.IsServer();
			}
			return false;
		}

		private static string ReadZdo(Character character, string key)
		{
			ZNetView val = (((Object)(object)character == (Object)null) ? null : ((Component)character).GetComponent<ZNetView>());
			if (!((Object)(object)val != (Object)null) || !val.IsValid())
			{
				return string.Empty;
			}
			return val.GetZDO().GetString(key, string.Empty);
		}

		private static void DestroyEnemy(ArenaEnemyHandle handle)
		{
			Enemies.Remove(handle.EnemyId);
			DestroyArenaCharacter(handle.Character);
		}

		private static void DestroyArenaCharacter(Character character)
		{
			if (!((Object)(object)character == (Object)null))
			{
				ArenaRuleContext.ForgetEnemy(character);
				if ((Object)(object)ZNetScene.instance != (Object)null)
				{
					ZNetScene.instance.Destroy(((Component)character).gameObject);
				}
				else
				{
					Object.Destroy((Object)(object)((Component)character).gameObject);
				}
			}
		}

		private static void RefreshParticipantCollisions()
		{
			List<Player> list = (from player in Player.GetAllPlayers()
				where (Object)(object)player != (Object)null && (ResolveRole(player.GetPlayerID()) == ArenaRole.Spectator || ResolveRole(player.GetPlayerID()) == ArenaRole.Queued)
				select player).ToList();
			if (list.Count == 0)
			{
				return;
			}
			List<Character> list2 = (from handle in Enemies.Values
				select handle.Character into character
				where (Object)(object)character != (Object)null
				select character).ToList();
			list2.AddRange((IEnumerable<Character>)(from player in Player.GetAllPlayers()
				where (Object)(object)player != (Object)null && ResolveRole(player.GetPlayerID()) == ArenaRole.Combatant
				select player));
			foreach (Player item in list)
			{
				Collider[] componentsInChildren = ((Component)item).GetComponentsInChildren<Collider>(true);
				foreach (Character item2 in list2)
				{
					if ((Object)(object)item2 == (Object)(object)item)
					{
						continue;
					}
					Collider[] componentsInChildren2 = ((Component)item2).GetComponentsInChildren<Collider>(true);
					Collider[] array = componentsInChildren;
					foreach (Collider val in array)
					{
						Collider[] array2 = componentsInChildren2;
						foreach (Collider val2 in array2)
						{
							if ((Object)(object)val != (Object)null && (Object)(object)val2 != (Object)null)
							{
								Physics.IgnoreCollision(val, val2, true);
							}
						}
					}
				}
			}
		}

		private static void RestoreFoods(Player player, IList<FoodStateSnapshot> foods)
		{
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Expected O, but got Unknown
			List<Food> foods2 = player.GetFoods();
			foods2.Clear();
			if (foods == null || (Object)(object)ObjectDB.instance == (Object)null)
			{
				return;
			}
			foreach (FoodStateSnapshot food in foods)
			{
				GameObject itemPrefab = ObjectDB.instance.GetItemPrefab(food.ItemPrefabName);
				ItemDrop val = (((Object)(object)itemPrefab == (Object)null) ? null : itemPrefab.GetComponent<ItemDrop>());
				if (!((Object)(object)val == (Object)null))
				{
					foods2.Add(new Food
					{
						m_name = food.ItemPrefabName,
						m_item = val.m_itemData,
						m_time = food.RemainingSeconds,
						m_health = food.Health,
						m_stamina = food.Stamina,
						m_eitr = food.Eitr
					});
				}
			}
		}

		private static void RefreshFoodStats(Player player)
		{
			if ((Object)(object)player == (Object)null || PlayerUpdateFoodMethod == null)
			{
				return;
			}
			try
			{
				PlayerUpdateFoodMethod.Invoke(player, new object[2] { 0f, true });
			}
			catch (Exception ex)
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogWarning((object)("Could not refresh arena food totals: " + ex.Message));
				}
			}
		}

		private static float GetRestedRemainingSeconds(Player player)
		{
			object obj;
			if (player == null)
			{
				obj = null;
			}
			else
			{
				SEMan sEMan = ((Character)player).GetSEMan();
				obj = ((sEMan != null) ? sEMan.GetStatusEffect(SEMan.s_statusEffectRested) : null);
			}
			StatusEffect val = (StatusEffect)obj;
			if (!((Object)(object)val == (Object)null))
			{
				return Math.Max(0f, val.GetRemaningTime());
			}
			return 0f;
		}

		private static void RestoreRested(Player player, float remainingSeconds)
		{
			if (!((Object)(object)player == (Object)null) && !(remainingSeconds <= 0f))
			{
				SEMan sEMan = ((Character)player).GetSEMan();
				StatusEffect val = sEMan.AddStatusEffect(SEMan.s_statusEffectRested, false, 0, 0f);
				val = val ?? sEMan.GetStatusEffect(SEMan.s_statusEffectRested);
				if ((Object)(object)val != (Object)null)
				{
					val.m_ttl = remainingSeconds;
					val.ResetTime();
				}
			}
		}

		private static void RestoreStackCounts(Inventory inventory, IDictionary<string, int> expected)
		{
			if (inventory == null || expected == null || (Object)(object)ObjectDB.instance == (Object)null)
			{
				return;
			}
			foreach (KeyValuePair<string, int> pair in expected)
			{
				int num = (from item in inventory.GetAllItems()
					where (Object)(object)item?.m_dropPrefab != (Object)null && ((Object)item.m_dropPrefab).name == pair.Key
					select item).Sum((ItemData item) => item.m_stack);
				int num2 = pair.Value - num;
				if (num2 > 0)
				{
					GameObject itemPrefab = ObjectDB.instance.GetItemPrefab(pair.Key);
					if ((Object)(object)itemPrefab != (Object)null)
					{
						inventory.AddItem(itemPrefab, num2);
					}
				}
			}
		}

		private static void RestoreDurability(Inventory inventory, IDictionary<string, float> expected)
		{
			if (inventory == null || expected == null)
			{
				return;
			}
			Dictionary<string, Queue<float>> dictionary = (from pair in expected
				group pair by pair.Key.Substring(pair.Key.IndexOf(':') + 1)).ToDictionary<IGrouping<string, KeyValuePair<string, float>>, string, Queue<float>>((IGrouping<string, KeyValuePair<string, float>> group) => group.Key, (IGrouping<string, KeyValuePair<string, float>> group) => new Queue<float>(group.Select((KeyValuePair<string, float> pair) => pair.Value)), StringComparer.Ordinal);
			foreach (ItemData item in from item in inventory.GetAllItems()
				where item?.m_equipped ?? false
				select item)
			{
				string key = (((Object)(object)item.m_dropPrefab == (Object)null) ? item.m_shared.m_name : ((Object)item.m_dropPrefab).name);
				if (dictionary.TryGetValue(key, out var value) && value.Count > 0)
				{
					item.m_durability = value.Dequeue();
				}
			}
		}

		private static void AddCount(IDictionary<string, int> counts, string key, int amount)
		{
			counts[key] = (counts.TryGetValue(key, out var value) ? (value + amount) : amount);
		}

		private static PositionData ToPositionData(Vector3 position)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			return new PositionData
			{
				X = position.x,
				Y = position.y,
				Z = position.z
			};
		}

		private static Vector3 ToVector3(PositionData position)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			return new Vector3(position.X, position.Y, position.Z);
		}

		private static bool Near(PositionData first, PositionData second, float radius)
		{
			float num = first.X - second.X;
			float num2 = first.Z - second.Z;
			return num * num + num2 * num2 <= radius * radius;
		}

		private static bool Near3D(PositionData first, PositionData second, float radius)
		{
			float num = first.X - second.X;
			float num2 = first.Y - second.Y;
			float num3 = first.Z - second.Z;
			return num * num + num2 * num2 + num3 * num3 <= radius * radius;
		}

		private static string ShortId(string value)
		{
			if (string.IsNullOrWhiteSpace(value))
			{
				return "new";
			}
			string text = value.Replace("-", string.Empty);
			return text.Substring(0, Math.Min(6, text.Length));
		}

		private static ArenaMarkerSet CopyMarkers(ArenaMarkerSet source)
		{
			if (source == null)
			{
				return null;
			}
			return new ArenaMarkerSet
			{
				StagingPosition = source.StagingPosition,
				CombatantStartPosition = source.CombatantStartPosition,
				HubGatePosition = source.HubGatePosition,
				EnemySpawnPositions = ((source.EnemySpawnPositions == null) ? new List<PositionData>() : new List<PositionData>(source.EnemySpawnPositions))
			};
		}

		private static bool MarkersEqual(ArenaMarkerSet first, ArenaMarkerSet second)
		{
			if (first == null || second == null || first.EnemySpawnPositions == null || second.EnemySpawnPositions == null || first.EnemySpawnPositions.Count != second.EnemySpawnPositions.Count)
			{
				return false;
			}
			if (!SamePosition(first.StagingPosition, second.StagingPosition) || !SamePosition(first.CombatantStartPosition, second.CombatantStartPosition) || !SamePosition(first.HubGatePosition, second.HubGatePosition))
			{
				return false;
			}
			for (int i = 0; i < first.EnemySpawnPositions.Count; i++)
			{
				if (!SamePosition(first.EnemySpawnPositions[i], second.EnemySpawnPositions[i]))
				{
					return false;
				}
			}
			return true;
		}

		private static bool SamePosition(PositionData first, PositionData second)
		{
			if (Math.Abs(first.X - second.X) < 0.001f && Math.Abs(first.Y - second.Y) < 0.001f)
			{
				return Math.Abs(first.Z - second.Z) < 0.001f;
			}
			return false;
		}
	}
}
namespace ArenaGuard.Rules
{
	internal static class ArenaAdminPermissionPolicy
	{
		internal static bool CanBuild(bool isAuthenticatedAdmin, bool isCombatant, bool enabled)
		{
			if (enabled && isAuthenticatedAdmin)
			{
				return !isCombatant;
			}
			return false;
		}

		internal static bool CanModifyTerrain(bool isAuthenticatedAdmin, bool isCombatant, bool enabled, bool devcommandsEnabled)
		{
			if (enabled && devcommandsEnabled && isAuthenticatedAdmin)
			{
				return !isCombatant;
			}
			return false;
		}

		internal static bool CanPickup(ArenaRole role, bool isAuthenticatedAdmin, bool enabled)
		{
			if (role == ArenaRole.Visitor || role == ArenaRole.Administrator)
			{
				return true;
			}
			return role != ArenaRole.Combatant && enabled && isAuthenticatedAdmin;
		}
	}
	internal static class ArenaAdminVisualPolicy
	{
		internal static bool ShouldShow(bool isAuthenticatedAdmin, bool localToggleEnabled)
		{
			return isAuthenticatedAdmin && localToggleEnabled;
		}
	}
	internal static class ArenaConsumablePolicy
	{
		internal static bool IsAllowed(bool isConsumable, bool suppliesFood, bool restoresHealth, bool restoresStamina, bool restoresEitr)
		{
			if (isConsumable && !suppliesFood)
			{
				return restoresHealth || restoresStamina || restoresEitr;
			}
			return false;
		}
	}
	internal static class ArenaDurationFormatter
	{
		internal static string FormatHms(long milliseconds)
		{
			long num = Math.Max(0L, milliseconds) / 1000;
			long num2 = num / 3600;
			long num3 = num / 60 % 60;
			long num4 = num % 60;
			return num2.ToString(CultureInfo.InvariantCulture) + ":" + num3.ToString("00", CultureInfo.InvariantCulture) + ":" + num4.ToString("00", CultureInfo.InvariantCulture);
		}
	}
	internal enum ArenaFoodTab
	{
		Health,
		Stamina,
		Eitr
	}
	internal static class ArenaFoodIndexPolicy
	{
		internal const float SpecialistRatio = 1.2f;

		internal static ArenaFoodTab Classify(float health, float stamina, float eitr)
		{
			if (eitr > 0f)
			{
				return ArenaFoodTab.Eitr;
			}
			if (health >= stamina * 1.2f)
			{
				return ArenaFoodTab.Health;
			}
			if (stamina >= health * 1.2f)
			{
				return ArenaFoodTab.Stamina;
			}
			if (!(health >= stamina))
			{
				return ArenaFoodTab.Stamina;
			}
			return ArenaFoodTab.Health;
		}

		internal static bool IsBalanced(float health, float stamina, float eitr)
		{
			if (eitr <= 0f && health < stamina * 1.2f)
			{
				return stamina < health * 1.2f;
			}
			return false;
		}

		internal static float Strength(ArenaFoodTab tab, float health, float stamina, float eitr)
		{
			return tab switch
			{
				ArenaFoodTab.Health => Math.Max(0f, health), 
				ArenaFoodTab.Stamina => Math.Max(0f, stamina), 
				_ => Math.Max(0f, eitr), 
			};
		}
	}
	internal static class ArenaFoodSelectionPolicy
	{
		internal const int RequiredFoodCount = 3;

		internal static bool IsValid(IEnumerable<string> selectedPrefabNames, ISet<string> eligiblePrefabNames)
		{
			if (selectedPrefabNames == null || eligiblePrefabNames == null)
			{
				return false;
			}
			HashSet<string> hashSet = new HashSet<string>(StringComparer.Ordinal);
			foreach (string selectedPrefabName in selectedPrefabNames)
			{
				string text = selectedPrefabName?.Trim();
				if (string.IsNullOrWhiteSpace(text) || !hashSet.Add(text) || !eligiblePrefabNames.Contains(text))
				{
					return false;
				}
			}
			return hashSet.Count == 3;
		}
	}
	[HarmonyPatch(typeof(Player), "GetJogSpeedFactor")]
	[HarmonyAfter(new string[] { "nex.SpeedyPaths" })]
	internal static class ArenaJogSpeedFactorPatch
	{
		[HarmonyPostfix]
		[HarmonyPriority(800)]
		private static void Postfix(Player __instance, ref float __result)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)__instance == (Object)null))
			{
				__result = ArenaMovementSpeedPolicy.NormalizeJog(ArenaRuleContext.IsProtectedPoint(((Component)__instance).transform.position), __result, ((Character)__instance).GetEquipmentMovementModifier());
			}
		}
	}
	[HarmonyPatch(typeof(Player), "GetRunSpeedFactor")]
	[HarmonyAfter(new string[] { "nex.SpeedyPaths" })]
	internal static class ArenaRunSpeedFactorPatch
	{
		[HarmonyPostfix]
		[HarmonyPriority(800)]
		private static void Postfix(Player __instance, ref float __result)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)__instance == (Object)null))
			{
				__result = ArenaMovementSpeedPolicy.NormalizeRun(ArenaRuleContext.IsProtectedPoint(((Component)__instance).transform.position), __result, ((Character)__instance).GetSkills().GetSkillFactor((SkillType)102), ((Character)__instance).GetEquipmentMovementModifier());
			}
		}
	}
	internal static class SpeedyPathsCompatibility
	{
		internal const string PluginGuid = "nex.SpeedyPaths";

		private const string ClientTypeName = "SpeedyPaths.SpeedyPathsClientMod";

		private const string ModifierMethodName = "GetSpeedyPathModifier";

		internal static void TryInstall(Harmony harmony)
		{
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Expected O, but got Unknown
			if (harmony == null)
			{
				throw new ArgumentNullException("harmony");
			}
			Type type = AccessTools.TypeByName("SpeedyPaths.SpeedyPathsClientMod");
			MethodInfo methodInfo = ((type == null) ? null : AccessTools.Method(type, "GetSpeedyPathModifier", new Type[1] { typeof(Player) }, (Type[])null));
			MethodInfo methodInfo2 = AccessTools.Method(typeof(SpeedyPathsCompatibility), "NeutralizeSpeedModifier", (Type[])null, (Type[])null);
			if (!(methodInfo == null) && !(methodInfo2 == null))
			{
				harmony.Patch((MethodBase)methodInfo, (HarmonyMethod)null, new HarmonyMethod(methodInfo2)
				{
					priority = 800
				}, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogInfo((object)"Speedy Paths compatibility enabled: path speed bonuses are suppressed inside arenas.");
				}
			}
		}

		private static void NeutralizeSpeedModifier(Player __0, ref float __result)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)__0 != (Object)null && ArenaRuleContext.IsProtectedPoint(((Component)__0).transform.position))
			{
				__result = 1f;
			}
		}
	}
	internal static class ArenaMovementSpeedPolicy
	{
		internal static float NormalizeJog(bool insideArena, float currentFactor, float equipmentMovementModifier)
		{
			if (!insideArena)
			{
				return currentFactor;
			}
			return 1f + equipmentMovementModifier;
		}

		internal static float NormalizeRun(bool insideArena, float currentFactor, float runSkillFactor, float equipmentMovementModifier)
		{
			if (!insideArena)
			{
				return currentFactor;
			}
			return (1f + runSkillFactor * 0.25f) * (1f + equipmentMovementModifier * 1.5f);
		}
	}
	internal static class ArenaQueuePromptPolicy
	{
		internal static bool ShouldOpen(bool isCalledForLocalPlayer, string displayedSessionId, string incomingSessionId)
		{
			if (isCalledForLocalPlayer && !string.IsNullOrWhiteSpace(incomingSessionId))
			{
				return !string.Equals(displayedSessionId, incomingSessionId, StringComparison.Ordinal);
			}
			return false;
		}
	}
	internal static class ArenaRuleContext
	{
		private sealed class CachedEnemyArena
		{
			internal bool Initialized;

			internal string ArenaId;

			internal float RefreshAfter;
		}

		private struct CachedCombatant
		{
			internal long PlayerId;

			internal float RefreshAfter;
		}

		private static ConditionalWeakTable<Character, CachedEnemyArena> _enemyArenaCache = new ConditionalWeakTable<Character, CachedEnemyArena>();

		private static readonly Dictionary<string, CachedCombatant> CombatantCache = new Dictionary<string, CachedCombatant>(StringComparer.Ordinal);

		internal static Func<Vector3, bool> IsProtectedPoint = (Vector3 _) => false;

		internal static Func<Vector3, bool> IsActiveProtectedPoint = (Vector3 _) => false;

		internal static Func<Player, bool> IsAdministrator = (Player _) => false;

		internal static Func<bool> AdminsMayModifyTerrain = () => false;

		internal static Func<bool> AdminsMayBuild = () => false;

		internal static Func<bool> AdminsMayPickupDroppedItems = () => false;

		internal static Func<bool> AreLocalDevcommandsEnabled = () => false;

		internal static Func<long, ArenaRole> ResolveRole = (long _) => ArenaRole.Visitor;

		internal static Func<Character, string> ResolveEnemyArenaId = (Character _) => (string)null;

		internal static Func<string, long> ResolveCombatant = (string _) => 0L;

		internal static Action<long> ReportLethalDamage = delegate
		{
		};

		internal static Action<Character> ReportArenaEnemyDeath = delegate
		{
		};

		internal static Action<Character, GameObject> RegisterArenaSummon = delegate
		{
		};

		internal static ArenaRole GetRole(Player player)
		{
			if ((Object)(object)player == (Object)null)
			{
				return ArenaRole.Visitor;
			}
			try
			{
				return ResolveRole(player.GetPlayerID());
			}
			catch (Exception ex)
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogWarning((object)("Arena role lookup failed: " + ex.Message));
				}
				return ArenaRole.Visitor;
			}
		}

		internal static bool IsCombatant(Player player)
		{
			return GetRole(player) == ArenaRole.Combatant;
		}

		internal static bool CanAdminBuild(Player player)
		{
			return ArenaAdminPermissionPolicy.CanBuild((Object)(object)player != (Object)null && IsAdministrator(player), IsCombatant(player), AdminsMayBuild());
		}

		internal static bool CanAdminModifyTerrain(Player player)
		{
			return ArenaAdminPermissionPolicy.CanModifyTerrain((Object)(object)player != (Object)null && IsAdministrator(player), IsCombatant(player), AdminsMayModifyTerrain(), AreLocalDevcommandsEnabled());
		}

		internal static bool CanPickupDroppedItems(Player player)
		{
			return ArenaAdminPermissionPolicy.CanPickup(GetRole(player), (Object)(object)player != (Object)null && IsAdministrator(player), AdminsMayPickupDroppedItems());
		}

		internal static bool IsProtectedDamage(Component target, HitData hit)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)target != (Object)null) || !IsProtectedPoint(target.transform.position))
			{
				if (hit != null)
				{
					return IsProtectedPoint(hit.m_point);
				}
				return false;
			}
			return true;
		}

		internal static bool IsSpectator(Player player)
		{
			ArenaRole role = GetRole(player);
			if (role != ArenaRole.Spectator)
			{
				return role == ArenaRole.Queued;
			}
			return true;
		}

		internal static bool IsArenaParticipant(Player player)
		{
			ArenaRole role = GetRole(player);
			if (role != ArenaRole.Combatant)
			{
				return role == ArenaRole.Spectator;
			}
			return true;
		}

		internal static string GetEnemyArenaId(Character character)
		{
			if ((Object)(object)character == (Object)null)
			{
				return null;
			}
			if (!_enemyArenaCache.TryGetValue(character, out var value))
			{
				value = new CachedEnemyArena();
				_enemyArenaCache.Add(character, value);
			}
			float unscaledTime = Time.unscaledTime;
			if (value.Initialized && (!string.IsNullOrEmpty(value.ArenaId) || unscaledTime < value.RefreshAfter))
			{
				return value.ArenaId;
			}
			value.ArenaId = ResolveEnemyArenaId(character);
			value.Initialized = true;
			value.RefreshAfter = unscaledTime + 1f;
			return value.ArenaId;
		}

		internal static void CacheEnemyArenaId(Character character, string arenaId)
		{
			if (!((Object)(object)character == (Object)null))
			{
				if (!_enemyArenaCache.TryGetValue(character, out var value))
				{
					value = new CachedEnemyArena();
					_enemyArenaCache.Add(character, value);
				}
				value.ArenaId = arenaId;
				value.Initialized = true;
				value.RefreshAfter = float.PositiveInfinity;
			}
		}

		internal static void ForgetEnemy(Character character)
		{
			if ((Object)(object)character != (Object)null)
			{
				_enemyArenaCache.Remove(character);
			}
		}

		internal static long GetCombatantId(string arenaId)
		{
			if (string.IsNullOrEmpty(arenaId))
			{
				return 0L;
			}
			float unscaledTime = Time.unscaledTime;
			if (CombatantCache.TryGetValue(arenaId, out var value) && unscaledTime < value.RefreshAfter)
			{
				return value.PlayerId;
			}
			long num = ResolveCombatant(arenaId);
			CombatantCache[arenaId] = new CachedCombatant
			{
				PlayerId = num,
				RefreshAfter = unscaledTime + 0.25f
			};
			return num;
		}

		internal static bool IsRecoveryConsumable(ItemData item)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Invalid comparison between Unknown and I4
			if (item?.m_shared == null || (int)item.m_shared.m_itemType != 2)
			{
				return false;
			}
			StatusEffect consumeStatusEffect = item.m_shared.m_consumeStatusEffect;
			SE_Stats val = (SE_Stats)(object)((consumeStatusEffect is SE_Stats) ? consumeStatusEffect : null);
			if ((Object)(object)val != (Object)null)
			{
				if (!(val.m_healthUpFront > 0f) && !(val.m_healthOverTime > 0f) && !(val.m_healthPerTick > 0f) && !(val.m_staminaUpFront > 0f) && !(val.m_staminaOverTime > 0f) && !(val.m_eitrUpFront > 0f))
				{
					return val.m_eitrOverTime > 0f;
				}
				return true;
			}
			return false;
		}

		internal static bool IsAllowedArenaConsumable(ItemData item)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Invalid comparison between Unknown and I4
			if (item?.m_shared == null)
			{
				return false;
			}
			StatusEffect consumeStatusEffect = item.m_shared.m_consumeStatusEffect;
			SE_Stats val = (SE_Stats)(object)((consumeStatusEffect is SE_Stats) ? consumeStatusEffect : null);
			return ArenaConsumablePolicy.IsAllowed((int)item.m_shared.m_itemType == 2, item.m_shared.m_food > 0f || item.m_shared.m_foodStamina > 0f || item.m_shared.m_foodEitr > 0f, (Object)(object)val != (Object)null && (val.m_healthUpFront > 0f || val.m_healthOverTime > 0f || val.m_healthPerTick > 0f), (Object)(object)val != (Object)null && (val.m_staminaUpFront > 0f || val.m_staminaOverTime > 0f), (Object)(object)val != (Object)null && (val.m_eitrUpFront > 0f || val.m_eitrOverTime > 0f));
		}

		internal static void Reset()
		{
			IsProtectedPoint = (Vector3 _) => false;
			IsActiveProtectedPoint = (Vector3 _) => false;
			IsAdministrator = (Player _) => false;
			AdminsMayModifyTerrain = () => false;
			AdminsMayBuild = () => false;
			AdminsMayPickupDroppedItems = () => false;
			AreLocalDevcommandsEnabled = () => false;
			ResolveRole = (long _) => ArenaRole.Visitor;
			ResolveEnemyArenaId = (Character _) => (string)null;
			ResolveCombatant = (string _) => 0L;
			ReportLethalDamage = delegate
			{
			};
			ReportArenaEnemyDeath = delegate
			{
			};
			RegisterArenaSummon = delegate
			{
			};
			_enemyArenaCache = new ConditionalWeakTable<Character, CachedEnemyArena>();
			CombatantCache.Clear();
		}
	}
	[HarmonyPatch(typeof(SpawnSystem), "IsSpawnPointGood")]
	internal static class ProtectedNaturalSpawnPatch
	{
		[HarmonyPostfix]
		private static void Postfix(ref Vector3 spawnPoint, ref bool __result)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			if (__result && ArenaRuleContext.IsProtectedPoint(spawnPoint))
			{
				__result = false;
			}
		}
	}
	[HarmonyPatch(typeof(CreatureSpawner), "Spawn")]
	internal static class ProtectedCreatureSpawnerPatch
	{
		[HarmonyPrefix]
		private static bool Prefix(CreatureSpawner __instance, ref ZNetView __result)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)__instance == (Object)null || !ArenaRuleContext.IsProtectedPoint(((Component)__instance).transform.position))
			{
				return true;
			}
			__result = null;
			return false;
		}
	}
	[HarmonyPatch(typeof(SpawnArea), "FindSpawnPoint")]
	internal static class ProtectedSpawnAreaPatch
	{
		[HarmonyPostfix]
		private static void Postfix(ref Vector3 point, ref bool __result)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			if (__result && ArenaRuleContext.IsProtectedPoint(point))
			{
				__result = false;
			}
		}
	}
	[HarmonyPatch]
	internal static class ArenaSpawnAbilityPatch
	{
		private static readonly FieldInfo OwnerField = AccessTools.Field(typeof(SpawnAbility), "m_owner");

		private static FieldInfo _abilityField;

		private static MethodBase TargetMethod()
		{
			MethodInfo methodInfo = AccessTools.Method(typeof(SpawnAbility), "Spawn", (Type[])null, (Type[])null);
			MethodInfo methodInfo2 = ((methodInfo == null) ? null : AccessTools.EnumeratorMoveNext((MethodBase)methodInfo));
			_abilityField = ((methodInfo2 == null) ? null : AccessTools.Field(methodInfo2.DeclaringType, "<>4__this"));
			if (methodInfo2 == null || _abilityField == null || OwnerField == null)
			{
				throw new MissingMethodException("Valheim SpawnAbility.Spawn state machine is unavailable.");
			}
			return methodInfo2;
		}

		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
		{
			int patchedInstantiations = 0;
			foreach (CodeInstruction instruction in instructions)
			{
				yield return instruction;
				if (instruction.operand is MethodInfo methodInfo && !(methodInfo.DeclaringType != typeof(Object)) && !(methodInfo.Name != "Instantiate") && methodInfo.IsGenericMethod && methodInfo.GetGenericArguments().Length == 1 && !(methodInfo.GetGenericArguments()[0] != typeof(GameObject)) && methodInfo.GetParameters().Length == 3)
				{
					yield return new CodeInstruction(OpCodes.Dup, (object)null);
					yield return new CodeInstruction(OpCodes.Ldarg_0, (object)null);
					yield return new CodeInstruction(OpCodes.Ldfld, (object)_abilityField);
					yield return new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(ArenaSpawnAbilityPatch), "RegisterSpawned", (Type[])null, (Type[])null));
					patchedInstantiations++;
				}
			}
			if (patchedInstantiations != 1)
			{
				throw new InvalidOperationException("ArenaGuard expected exactly one SpawnAbility character creation point but found " + patchedInstantiations + ".");
			}
		}

		private static void RegisterSpawned(GameObject spawned, SpawnAbility source)
		{
			Character val = (Character)(((Object)(object)source == (Object)null) ? null : /*isinst with value type is only supported in some contexts*/);
			if ((Object)(object)val != (Object)null && (Object)(object)spawned != (Object)null)
			{
				ArenaRuleContext.RegisterArenaSummon(val, spawned);
			}
		}
	}
	[HarmonyPatch(typeof(WearNTear), "Damage", new Type[] { typeof(HitData) })]
	internal static class ProtectedStructureDamagePatch
	{
		[HarmonyPrefix]
		private static bool Prefix(WearNTear __instance, HitData hit)
		{
			return !ArenaRuleContext.IsProtectedDamage((Component)(object)__instance, hit);
		}
	}
	[HarmonyPatch(typeof(WearNTear), "ApplyDamage", new Type[]
	{
		typeof(float),
		typeof(HitData)
	})]
	internal static class ProtectedStructureApplyDamagePatch
	{
		[HarmonyPrefix]
		private static bool Prefix(WearNTear __instance, HitData hitData, ref bool __result)
		{
			if (!ArenaRuleContext.IsProtectedDamage((Component)(object)__instance, hitData))
			{
				return true;
			}
			__result = false;
			return false;
		}
	}
	[HarmonyPatch(typeof(Piece), "DropResources", new Type[] { typeof(HitData) })]
	internal static class ProtectedStructureDropPatch
	{
		[HarmonyPrefix]
		private static bool Prefix(Piece __instance, HitData hitData)
		{
			if (hitData != null)
			{
				return !ArenaRuleContext.IsProtectedDamage((Component)(object)__instance, hitData);
			}
			return true;
		}
	}
	[HarmonyPatch]
	internal static class ProtectedWorldObjectDamagePatch
	{
		private static IEnumerable<MethodBase> TargetMethods()
		{
			yield return RequireDamageMethod(typeof(WearNTear), "RPC_Damage", typeof(long), typeof(HitData));
			yield return RequireDamageMethod(typeof(Destructible), "RPC_Damage", typeof(long), typeof(HitData));
			yield return RequireDamageMethod(typeof(MineRock), "RPC_Hit", typeof(long), typeof(HitData), typeof(int));
			yield return RequireDamageMethod(typeof(TreeBase), "RPC_Damage", typeof(long), typeof(HitData));
			yield return RequireDamageMethod(typeof(TreeLog), "RPC_Damage", typeof(long), typeof(HitData));
		}

		private static MethodBase RequireDamageMethod(Type type, string name, params Type[] parameters)
		{
			MethodInfo methodInfo = AccessTools.DeclaredMethod(type, name, parameters, (Type[])null);
			if (methodInfo == null)
			{
				throw new MissingMethodException(type.FullName, name);
			}
			return methodInfo;
		}

		[HarmonyPrefix]
		private static bool Prefix(Component __instance, HitData hit)
		{
			return !ArenaRuleContext.IsProtectedDamage(__instance, hit);
		}
	}
	[HarmonyPatch(typeof(MineRock5), "DamageArea", new Type[]
	{
		typeof(int),
		typeof(HitData)
	})]
	internal static class ProtectedMineRockDamagePatch
	{
		[HarmonyPrefix]
		private static bool Prefix(MineRock5 __instance, HitData hit, ref bool __result)
		{
			if (!ArenaRuleContext.IsProtectedDamage((Component)(object)__instance, hit))
			{
				return true;
			}
			__result = false;
			return false;
		}
	}
	[HarmonyPatch(typeof(Player), "TryPlacePiece", new Type[] { typeof(Piece) })]
	internal static class ProtectedBuildPatch
	{
		[HarmonyPrefix]
		private static bool Prefix(Player __instance, ref bool __result)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)__instance == (Object)null || !ArenaRuleContext.IsProtectedPoint(((Component)__instance).transform.position))
			{
				return true;
			}
			if (ArenaRuleContext.CanAdminBuild(__instance))
			{
				return true;
			}
			__result = false;
			((Character)__instance).Message((MessageType)2, "$arenaguard_admin_build_only", 0, (Sprite)null);
			return false;
		}
	}
	[HarmonyPatch(typeof(Player), "CheckCanRemovePiece", new Type[] { typeof(Piece) })]
	internal static class ProtectedDemolitionPatch
	{
		[HarmonyPrefix]
		private static bool Prefix(Player __instance, Piece piece, ref bool __result)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)piece == (Object)null || !ArenaRuleContext.IsProtectedPoint(((Component)piece).transform.position))
			{
				return true;
			}
			__result = ArenaRuleContext.CanAdminBuild(__instance);
			if (!__result && __instance != null)
			{
				((Character)__instance).Message((MessageType)2, "$arenaguard_admin_build_only", 0, (Sprite)null);
			}
			return false;
		}
	}
	[HarmonyPatch(typeof(TerrainOp), "Awake")]
	internal static class ProtectedTerrainPatch
	{
		[HarmonyPrefix]
		private static bool Prefix(TerrainOp __instance)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)__instance == (Object)null || !ArenaRuleContext.IsProtectedPoint(((Component)__instance).transform.position))
			{
				return true;
			}
			if (ArenaRuleContext.CanAdminModifyTerrain(Player.m_localPlayer))
			{
				return true;
			}
			Object.Destroy((Object)(object)((Component)__instance).gameObject);
			return false;
		}
	}
	[HarmonyPatch(typeof(Character), "RPC_Damage", new Type[]
	{
		typeof(long),
		typeof(HitData)
	})]
	internal static class SpectatorDamagePatch
	{
		[HarmonyPrefix]
		private static bool Prefix(Character __instance)
		{
			if (ArenaWorldObjects.IsChallengeHost(__instance))
			{
				return false;
			}
			Player val = (Player)(object)((__instance is Player) ? __instance : null);
			if (!((Object)(object)val == (Object)null))
			{
				return !ArenaRuleContext.IsSpectator(val);
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(Character), "ApplyDamage", new Type[]
	{
		typeof(HitData),
		typeof(bool),
		typeof(bool),
		typeof(DamageModifier)
	})]
	internal static class CombatantLethalDamagePatch
	{
		[HarmonyPostfix]
		private static void Postfix(Character __instance)
		{
			Player val = (Player)(object)((__instance is Player) ? __instance : null);
			if (!((Object)(object)val == (Object)null) && ArenaRuleContext.IsCombatant(val) && !(((Character)val).GetHealth() > 0f))
			{
				((Character)val).SetHealth(1f);
				ArenaRuleContext.ReportLethalDamage(val.GetPlayerID());
			}
		}
	}
	[HarmonyPatch(typeof(Character), "CheckDeath")]
	internal static class CombatantDeathSafetyPatch
	{
		[HarmonyPrefix]
		private static bool Prefix(Character __instance)
		{
			Player val = (Player)(object)((__instance is Player) ? __instance : null);
			if ((Object)(object)val != (Object)null)
			{
				if (!ArenaRuleContext.IsCombatant(val) || ((Character)val).GetHealth() > 0f)
				{
					return true;
				}
				((Character)val).SetHealth(1f);
				ArenaRuleContext.ReportLethalDamage(val.GetPlayerID());
				return false;
			}
			if (ArenaWorldObjects.IsChallengeHost(__instance))
			{
				if (__instance.GetHealth() <= 0f)
				{
					__instance.SetHealth(__instance.GetMaxHealth());
				}
				return false;
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(Player), "Interact", new Type[]
	{
		typeof(GameObject),
		typeof(bool),
		typeof(bool)
	})]
	internal static class SpectatorInteractionPatch
	{
		[HarmonyPrefix]
		private static bool Prefix(Player __instance, GameObject go)
		{
			if (!ArenaRuleContext.IsSpectator(__instance))
			{
				return true;
			}
			if ((Object)(object)go != (Object)null && ((Object)(object)go.GetComponentInParent<ArenaChallengeHostBehaviour>() != (Object)null || (Object)(object)go.GetComponentInParent<ArenaSignBehaviour>() != (Object)null))
			{
				return true;
			}
			if ((Object)(object)go != (Object)null && (Object)(object)go.GetComponentInParent<ItemDrop>() != (Object)null && ArenaRuleContext.CanPickupDroppedItems(__instance))
			{
				return true;
			}
			if ((Object)(object)__instance != (Object)null && ArenaRuleContext.IsAdministrator(__instance) && (Object)(object)go != (Object)null)
			{
				return (Object)(object)go.GetComponentInParent<ArenaWorldObjectBehaviour>() != (Object)null;
			}
			return false;
		}
	}
	[HarmonyPatch(typeof(Humanoid), "Pickup", new Type[]
	{
		typeof(GameObject),
		typeof(bool),
		typeof(bool)
	})]
	internal static class ArenaPickupPatch
	{
		[HarmonyPrefix]
		private static bool Prefix(Humanoid __instance, ref bool __result)
		{
			Player val = (Player)(object)((__instance is Player) ? __instance : null);
			if ((Object)(object)val == (Object)null || ArenaRuleContext.CanPickupDroppedItems(val))
			{
				return true;
			}
			__result = false;
			return false;
		}
	}
	[HarmonyPatch(typeof(Player), "AutoPickup")]
	internal static class ArenaAutoPickupPatch
	{
		[HarmonyPrefix]
		private static bool Prefix(Player __instance)
		{
			return ArenaRuleContext.CanPickupDroppedItems(__instance);
		}
	}
	[HarmonyPatch(typeof(Humanoid), "DropItem", new Type[]
	{
		typeof(Inventory),
		typeof(ItemData),
		typeof(int)
	})]
	internal static class ArenaDropPatch
	{
		[HarmonyPrefix]
		private static bool Prefix(Humanoid __instance, ItemData item, ref bool __result)
		{
			Player val = (Player)(object)((__instance is Player) ? __instance : null);
			if ((!((Object)(object)item?.m_dropPrefab != (Object)null) || !(((Object)item.m_dropPrefab).name == "ArenaGuard_AdminHammer")) && ((Object)(object)val == (Object)null || !ArenaRuleContext.IsArenaParticipant(val)))
			{
				return true;
			}
			__result = false;
			return false;
		}
	}
	[HarmonyPatch(typeof(Inventory), "MoveItemToThis", new Type[]
	{
		typeof(Inventory),
		typeof(ItemData)
	})]
	internal static class ArenaInventoryTransferPatch
	{
		[HarmonyPrefix]
		private static bool Prefix(Inventory __instance, Inventory fromInventory, ItemData item)
		{
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null || fromInventory != ((Humanoid)localPlayer).GetInventory() || __instance == fromInventory)
			{
				return true;
			}
			if (!((Object)(object)item?.m_dropPrefab != (Object)null) || !(((Object)item.m_dropPrefab).name == "ArenaGuard_AdminHammer"))
			{
				return !ArenaRuleContext.IsArenaParticipant(localPlayer);
			}
			return false;
		}
	}
	[HarmonyPatch(typeof(Inventory), "MoveItemToThis", new Type[]
	{
		typeof(Inventory),
		typeof(ItemData),
		typeof(int),
		typeof(int),
		typeof(int)
	})]
	internal static class ArenaInventoryTransferAtPatch
	{
		[HarmonyPrefix]
		private static bool Prefix(Inventory __instance, Inventory fromInventory, ItemData item, ref bool __result)
		{
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null || fromInventory != ((Humanoid)localPlayer).GetInventory() || __instance == fromInventory)
			{
				return true;
			}
			if ((!((Object)(object)item?.m_dropPrefab != (Object)null) || !(((Object)item.m_dropPrefab).name == "ArenaGuard_AdminHammer")) && !ArenaRuleContext.IsArenaParticipant(localPlayer))
			{
				return true;
			}
			__result = false;
			return false;
		}
	}
	[HarmonyPatch(typeof(InventoryGui), "DoCrafting")]
	internal static class ArenaCraftingPatch
	{
		[HarmonyPrefix]
		private static bool Prefix()
		{
			if (!((Object)(object)Player.m_localPlayer == (Object)null))
			{
				return !ArenaRuleContext.IsArenaParticipant(Player.m_localPlayer);
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(Humanoid), "CanConsumeItem", new Type[]
	{
		typeof(ItemData),
		typeof(bool)
	})]
	internal static class ArenaConsumablePatch
	{
		[HarmonyPostfix]
		private static void Postfix(Humanoid __instance, ItemData item, ref bool __result)
		{
			Player val = (Player)(object)((__instance is Player) ? __instance : null);
			if ((Object)(object)val != (Object)null && ArenaRuleContext.IsCombatant(val))
			{
				__result = __result && ArenaRuleContext.IsAllowedArenaConsumable(item);
			}
		}
	}
	[HarmonyPatch(typeof(Inventory), "RemoveItem", new Type[]
	{
		typeof(ItemData),
		typeof(int)
	})]
	internal static class ArenaAmmoPatch
	{
		[HarmonyPrefix]
		private static bool Prefix(Inventory __instance, ItemData item, ref bool __result)
		{
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Invalid comparison between Unknown and I4
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Invalid comparison between Unknown and I4
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)null || ((Humanoid)localPlayer).GetInventory() != __instance || !ArenaRuleContext.IsCombatant(localPlayer) || item?.m_shared == null)
			{
				return true;
			}
			ItemType itemType = item.m_shared.m_itemType;
			if ((int)itemType != 9 && (int)itemType != 23)
			{
				return true;
			}
			__result = true;
			return false;
		}
	}
	[HarmonyPatch(typeof(Skills), "RaiseSkill", new Type[]
	{
		typeof(SkillType),
		typeof(float)
	})]
	internal static class ArenaSkillGainPatch
	{
		[HarmonyPrefix]
		private static bool Prefix(Skills __instance)
		{
			foreach (Player allPlayer in Player.GetAllPlayers())
			{
				if ((Object)(object)allPlayer != (Object)null && (Object)(object)((Character)allPlayer).GetSkills() == (Object)(object)__instance && ArenaRuleContext.IsCombatant(allPlayer))
				{
					return false;
				}
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(Player), "DamageArmorDurability", new Type[] { typeof(HitData) })]
	internal static class ArenaArmorDurabilityPatch
	{
		[HarmonyPrefix]
		private static bool Prefix(Player __instance)
		{
			return !ArenaRuleContext.IsCombatant(__instance);
		}
	}
	[HarmonyPatch(typeof(Humanoid), "DrainEquipedItemDurability", new Type[]
	{
		typeof(ItemData),
		typeof(float)
	})]
	internal static class ArenaEquippedDurabilityPatch
	{
		[HarmonyPrefix]
		private static bool Prefix(Humanoid __instance)
		{
			Player val = (Player)(object)((__instance is Player) ? __instance : null);
			if (!((Object)(object)val == (Object)null))
			{
				return !ArenaRuleContext.IsCombatant(val);
			}
			return true;
		}
	}
	[HarmonyPatch]
	internal static class ArenaAttackDurabilityPatch
	{
		private static readonly FieldInfo CharacterField = AccessTools.Field(typeof(Attack), "m_character");

		private static readonly FieldInfo WeaponField = AccessTools.Field(typeof(Attack), "m_weapon");

		private static IEnumerable<MethodBase> TargetMethods()
		{
			string[] array = new string[4] { "ProjectileAttackTriggered", "DoNonAttack", "DoMeleeAttack", "DoAreaAttack" };
			string[] array2 = array;
			foreach (string text in array2)
			{
				MethodInfo methodInfo = AccessTools.Method(typeof(Attack), text, (Type[])null, (Type[])null);
				if (methodInfo != null)
				{
					yield return methodInfo;
				}
			}
		}

		[HarmonyPrefix]
		private static void Prefix(Attack __instance, out float? __state)
		{
			__state = null;
			object? obj = CharacterField?.GetValue(__instance);
			Player val = (Player)((obj is Player) ? obj : null);
			object? obj2 = WeaponField?.GetValue(__instance);
			ItemData val2 = (ItemData)((obj2 is ItemData) ? obj2 : null);
			if ((Object)(object)val != (Object)null && val2 != null && ArenaRuleContext.IsCombatant(val))
			{
				__state = val2.m_durability;
			}
		}

		[HarmonyPostfix]
		private static void Postfix(Attack __instance, float? __state)
		{
			if (__state.HasValue)
			{
				object? obj = WeaponField?.GetValue(__instance);
				ItemData val = (ItemData)((obj is ItemData) ? obj : null);
				if (val != null)
				{
					val.m_durability = __state.Value;
				}
			}
		}
	}
	[HarmonyPatch(typeof(BaseAI), "IsEnemy", new Type[]
	{
		typeof(Character),
		typeof(Character)
	})]
	internal static class ArenaEnemyTargetPatch
	{
		[HarmonyPrefix]
		private static bool Prefix(Character a, Character b, ref bool __result)
		{
			if (ArenaWorldObjects.IsChallengeHost(a) || ArenaWorldObjects.IsChallengeHost(b))
			{
				__result = false;
				return false;
			}
			string enemyArenaId = ArenaRuleContext.GetEnemyArenaId(a);
			string enemyArenaId2 = ArenaRuleContext.GetEnemyArenaId(b);
			if (!string.IsNullOrEmpty(enemyArenaId))
			{
				Player val = (Player)(object)((b is Player) ? b : null);
				__result = (Object)(object)val != (Object)null && val.GetPlayerID() == ArenaRuleContext.GetCombatantId(enemyArenaId);
				return false;
			}
			if (!string.IsNullOrEmpty(enemyArenaId2))
			{
				Player val2 = (Player)(object)((a is Player) ? a : null);
				__result = (Object)(object)val2 != (Object)null && val2.GetPlayerID() == ArenaRuleContext.GetCombatantId(enemyArenaId2);
				return false;
			}
			Player val3 = (Player)(object)((a is Player) ? a : null);
			if (val3 == null || !ArenaRuleContext.IsSpectator(val3))
			{
				Player val4 = (Player)(object)((b is Player) ? b : null);
				if (val4 == null || !ArenaRuleContext.IsSpectator(val4))
				{
					return true;
				}
			}
			__result = false;
			return false;
		}
	}
	[HarmonyPatch(typeof(CharacterDrop), "GenerateDropList")]
	internal static class ArenaEnemyDropListPatch
	{
		[HarmonyPrefix]
		private static bool Prefix(CharacterDrop __instance, ref List<KeyValuePair<GameObject, int>> __result)
		{
			Character val = (((Object)(object)__instance == (Object)null) ? null : ((Component)__instance).GetComponent<Character>());
			if ((Object)(object)val == (Object)null || string.IsNullOrEmpty(ArenaRuleContext.GetEnemyArenaId(val)))
			{
				return true;
			}
			__result = new List<KeyValuePair<GameObject, int>>();
			return false;
		}
	}
	[HarmonyPatch(typeof(Character), "OnDeath")]
	internal static class ArenaEnemyDeathPatch
	{
		[HarmonyPrefix]
		private static void Prefix(Character __instance)
		{
			if ((Object)(object)__instance != (Object)null && !string.IsNullOrEmpty(ArenaRuleContext.GetEnemyArenaId(__instance)))
			{
				ArenaRuleContext.ReportArenaEnemyDeath(__instance);
			}
		}
	}
	[HarmonyPatch(typeof(Container), "Interact", new Type[]
	{
		typeof(Humanoid),
		typeof(bool),
		typeof(bool)
	})]
	internal static class ArenaContainerPatch
	{
		[HarmonyPrefix]
		private static bool Prefix(Container __instance, ref bool __result)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)__instance == (Object)null || !ArenaRuleContext.IsActiveProtectedPoint(((Component)__instance).transform.position))
			{
				return true;
			}
			__result = false;
			return false;
		}
	}
	[HarmonyPatch(typeof(Door), "Interact", new Type[]
	{
		typeof(Humanoid),
		typeof(bool),
		typeof(bool)
	})]
	internal static class ArenaDoorPatch
	{
		[HarmonyPrefix]
		private static bool Prefix(Door __instance, ref bool __result)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)__instance == (Object)null || !ArenaRuleContext.IsActiveProtectedPoint(((Component)__instance).transform.position))
			{
				return true;
			}
			__result = false;
			return false;
		}
	}
	internal static class ArenaSpawnSelectionPolicy
	{
		internal static IList<int> BuildOrder(int markerCount, int spawnCount, int seed, int previousMarker = -1)
		{
			if (markerCount <= 0)
			{
				throw new ArgumentOutOfRangeException("markerCount");
			}
			if (spawnCount < 0)
			{
				throw new ArgumentOutOfRangeException("spawnCount");
			}
			List<int> list = new List<int>(spawnCount);
			Random random = new Random(seed);
			int num = ((previousMarker >= 0 && previousMarker < markerCount) ? previousMarker : (-1));
			while (list.Count < spawnCount)
			{
				List<int> list2 = new List<int>(markerCount);
				for (int i = 0; i < markerCount; i++)
				{
					list2.Add(i);
				}
				for (int num2 = list2.Count - 1; num2 > 0; num2--)
				{
					int index = random.Next(num2 + 1);
					int value = list2[num2];
					list2[num2] = list2[index];
					list2[index] = value;
				}
				if (list2.Count > 1 && list2[0] == num)
				{
					int index2 = 1 + random.Next(list2.Count - 1);
					int value2 = list2[0];
					list2[0] = list2[index2];
					list2[index2] = value2;
				}
				for (int j = 0; j < list2.Count; j++)
				{
					if (list.Count >= spawnCount)
					{
						break;
					}
					list.Add(list2[j]);
					num = list2[j];
				}
			}
			return list;
		}
	}
	internal static class ArenaWildlifePolicy
	{
		internal static bool ShouldRemoveCharacter(bool insideProtectedRadius, bool isPlayer, bool isTamed, bool isArenaMaster, bool isArenaEnemy, bool isPassiveWildlife)
		{
			return insideProtectedRadius && !isPlayer && !isTamed && !isArenaMaster && !isArenaEnemy && isPassiveWildlife;
		}
	}
}
namespace ArenaGuard.Persistence
{
	internal static class ArenaStore
	{
		[DataContract]
		private sealed class StoreFile
		{
			[DataMember(Name = "schemaVersion", Order = 1)]
			public int SchemaVersion;

			[DataMember(Name = "state", Order = 2)]
			public PersistedWorldState State;
		}

		private const int SchemaVersion = 3;

		private const int ScopeSchemaVersion = 2;

		private const int LegacySchemaVersion = 1;

		private const long MaximumSaveBytes = 67108864L;

		private const int MaximumCollectionEntries = 100000;

		private const int MaximumStartupBackups = 5;

		private static readonly object Sync = new object();

		private static PersistedWorldState _current = Empty(0L);

		internal static long WorldUid
		{
			get
			{
				lock (Sync)
				{
					return _current.WorldUid;
				}
			}
		}

		internal static PersistedWorldState Load(long worldUid)
		{
			if (worldUid == 0L)
			{
				throw new ArgumentOutOfRangeException("worldUid", "A non-zero world UID is required.");
			}
			string path = GetPath(worldUid);
			if (!File.Exists(path))
			{
				PersistedWorldState persistedWorldState = Empty(worldUid);
				lock (Sync)
				{
					_current = Clone(persistedWorldState);
					return persistedWorldState;
				}
			}
			try
			{
				CreateStartupBackup(path);
				FileInfo fileInfo = new FileInfo(path);
				if (fileInfo.Length <= 0 || fileInfo.Length > 67108864)
				{
					throw new SerializationException($"Arena state file length {fileInfo.Length} is invalid.");
				}
				StoreFile storeFile;
				using (FileStream fileStream = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.Read))
				{
					storeFile = (StoreFile)((XmlObjectSerializer)CreateSerializer()).ReadObject((Stream)fileStream);
				}
				if (storeFile == null || (storeFile.SchemaVersion != 3 && storeFile.SchemaVersion != 2 && storeFile.SchemaVersion != 1) || storeFile.State == null || storeFile.State.WorldUid != worldUid)
				{
					throw new SerializationException("Arena state schema or world UID does not match.");
				}
				if (storeFile.SchemaVersion == 1)
				{
					MigrateLegacyProgression(storeFile.State);
					ManualLogSource log = Plugin.Log;
					if (log != null)
					{
						log.LogInfo((object)"Migrated ArenaGuard world state from progression schema 1 to scope schema 2.");
					}
				}
				if (storeFile.SchemaVersion < 3)
				{
					InitializeArenaFoodSnapshots(storeFile.State);
					ManualLogSource log2 = Plugin.Log;
					if (log2 != null)
					{
						log2.LogInfo((object)"Migrated ArenaGuard resource snapshots to arena-food schema 3.");
					}
				}
				NormalizeAndValidate(storeFile.State, worldUid);
				PersistedWorldState persistedWorldState2 = Clone(storeFile.State);
				lock (Sync)
				{
					_current = Clone(persistedWorldState2);
				}
				ManualLogSource log3 = Plugin.Log;
				if (log3 != null)
				{
					log3.LogInfo((object)($"Loaded ArenaGuard world state {worldUid}: " + $"{persistedWorldState2.Arenas.Count} arena(s), {persistedWorldState2.Gates.Count} gate(s), " + $"{persistedWorldState2.Queue.Count} queued player(s), {persistedWorldState2.Leaderboard.Count} record(s)."));
				}
				return persistedWorldState2;
			}
			catch (Exception arg)
			{
				string arg2 = PreserveCorruptCopy(path);
				ManualLogSource log4 = Plugin.Log;
				if (log4 != null)
				{
					log4.LogError((object)("Could not load ArenaGuard state '" + path + "'. The world was opened with empty " + $"arena state. Preserved copy: '{arg2}'. {arg}"));
				}
				PersistedWorldState persistedWorldState3 = Empty(worldUid);
				lock (Sync)
				{
					_current = Clone(persistedWorldState3);
				}
				return persistedWorldState3;
			}
		}

		internal static bool Save(PersistedWorldState state)
		{
			if (state == null)
			{
				throw new ArgumentNullException("state");
			}
			if (state.WorldUid == 0L)
			{
				return false;
			}
			PersistedWorldState persistedWorldState = Clone(state);
			NormalizeAndValidate(persistedWorldState, state.WorldUid);
			string path = GetPath(persistedWorldState.WorldUid);
			string directoryName = Path.GetDirectoryName(path);
			string text = path + ".tmp-" + Guid.NewGuid().ToString("N");
			string destinationBackupFileName = path + ".bak";
			bool result;
			try
			{
				Directory.CreateDirectory(directoryName);
				using (FileStream fileStream = new FileStream(text, FileMode.CreateNew, FileAccess.Write, FileShare.None))
				{
					((XmlObjectSerializer)CreateSerializer()).WriteObject((Stream)fileStream, (object)new StoreFile
					{
						SchemaVersion = 3,
						State = persistedWorldState
					});
					fileStream.Flush(flushToDisk: true);
				}
				if (File.Exists(path))
				{
					File.Replace(text, path, destinationBackupFileName);
				}
				else
				{
					File.Move(text, path);
				}
				lock (Sync)
				{
					_current = Clone(persistedWorldState);
				}
				result = true;
			}
			catch (Exception arg)
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogError((object)$"Could not atomically save ArenaGuard state '{path}': {arg}");
				}
				result = false;
			}
			finally
			{
				try
				{
					if (File.Exists(text))
					{
						File.Delete(text);
					}
				}
				catch (Exception ex)
				{
					ManualLogSource log2 = Plugin.Log;
					if (log2 != null)
					{
						log2.LogWarning((object)("Could not remove ArenaGuard temporary state '" + text + "': " + ex.Message));
					}
				}
			}
			return result;
		}

		internal static bool RecordResult(LeaderboardEntry entry)
		{
			LeaderboardEntry candidate = NormalizeLeaderboardEntry(entry);
			PersistedWorldState state;
			lock (Sync)
			{
				if (_current.WorldUid == 0L)
				{
					return false;
				}
				int num = _current.Leaderboard.FindIndex((LeaderboardEntry current) => current.PlayerId == candidate.PlayerId && KeysEqual(current.Key, candidate.Key));
				if (num >= 0)
				{
					LeaderboardEntry existing = _current.Leaderboard[num];
					if (!IsBetter(candidate, existing))
					{
						return false;
					}
					_current.Leaderboard[num] = candidate;
				}
				else
				{
					_current.Leaderboard.Add(candidate);
				}
				state = Clone(_current);
			}
			return Save(state);
		}

		internal static List<LeaderboardEntry> GetLeaderboard(LeaderboardKey key)
		{
			LeaderboardKey normalizedKey = NormalizeLeaderboardKey(key);
			lock (Sync)
			{
				return (from entry in _current.Leaderboard
					where KeysEqual(entry.Key, normalizedKey)
					orderby entry.Completed descending, (!entry.Completed) ? entry.FurthestEncounterIndex : int.MinValue descending, entry.ElapsedMilliseconds, entry.RecordedUtc
					select entry).ThenBy<LeaderboardEntry, string>((LeaderboardEntry entry) => entry.PlayerName, StringComparer.OrdinalIgnoreCase).ThenBy((LeaderboardEntry entry) => entry.PlayerId).Select(CopyLeaderboardEntry)
					.ToList();
			}
		}

		internal static bool MarkInterrupted(ArenaSession session)
		{
			ArenaSession candidate = CopySession(session);
			ValidateInterruptedSession(candidate);
			PersistedWorldState state;
			lock (Sync)
			{
				if (_current.WorldUid == 0L)
				{
					return false;
				}
				_current.InterruptedSessions.RemoveAll((ArenaSession current) => string.Equals(current.SessionId, candidate.SessionId, StringComparison.Ordinal) || string.Equals(current.ArenaId, candidate.ArenaId, StringComparison.Ordinal) || current.Request?.PlayerId == candidate.Request?.PlayerId);
				_current.InterruptedSessions.Add(candidate);
				state = Clone(_current);
			}
			return Save(state);
		}

		internal static bool RemoveInterrupted(string sessionId)
		{
			sessionId = ArenaRegistry.NormalizeId(sessionId);
			if (sessionId == null)
			{
				return false;
			}
			PersistedWorldState state;
			lock (Sync)
			{
				if (_current.WorldUid == 0L || _current.InterruptedSessions.RemoveAll((ArenaSession session) => string.Equals(session.SessionId, sessionId, StringComparison.Ordinal)) == 0)
				{
					return false;
				}
				state = Clone(_current);
			}
			return Save(state);
		}

		internal static PersistedWorldState Snapshot()
		{
			lock (Sync)
			{
				return Clone(_current);
			}
		}

		internal static void Clear()
		{
			lock (Sync)
			{
				_current = Empty(0L);
			}
		}

		internal static string GetPath(long worldUid)
		{
			return Path.Combine(Paths.ConfigPath, "jg224.arenaguard.world-" + worldUid.ToString(CultureInfo.InvariantCulture) + ".json");
		}

		private static void CreateStartupBackup(string path)
		{
			try
			{
				string directoryName = Path.GetDirectoryName(path);
				string text = Path.GetFileName(path) + ".startup-";
				string destFileName = Path.Combine(directoryName, text + DateTime.UtcNow.ToString("yyyyMMdd-HHmmss-fff", CultureInfo.InvariantCulture) + "-" + Guid.NewGuid().ToString("N").Substring(0, 8) + ".bak");
				File.Copy(path, destFileName, overwrite: false);
				foreach (FileInfo item in (from file in new DirectoryInfo(directoryName).GetFiles(text + "*.bak", SearchOption.TopDirectoryOnly)
					orderby file.LastWriteTimeUtc descending
					select file).ThenByDescending<FileInfo, string>((FileInfo file) => file.Name, StringComparer.Ordinal).ToArray().Skip(5))
				{
					item.Delete();
				}
			}
			catch (Exception ex)
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogWarning((object)("Could not create ArenaGuard startup state backup for '" + path + "': " + ex.Message));
				}
			}
		}

		private static DataContractJsonSerializer CreateSerializer()
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Expected O, but got Unknown
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Expected O, but got Unknown
			return new DataContractJsonSerializer(typeof(StoreFile), new DataContractJsonSerializerSettings
			{
				UseSimpleDictionaryFormat = true,
				EmitTypeInformation = (EmitTypeInformation)2,
				MaxItemsInObjectGraph = int.MaxValue
			});
		}

		private static void MigrateLegacyProgression(PersistedWorldState state)
		{
			if (state == null)
			{
				return;
			}
			foreach (QueueEntry item in state.Queue ?? new List<QueueEntry>())
			{
				MigrateLegacyRequest(item?.Request);
			}
			foreach (ArenaSession item2 in state.InterruptedSessions ?? new List<ArenaSession>())
			{
				MigrateLegacyRequest(item2?.Request);
				if (item2?.Plan != null)
				{
					item2.Plan.CapMode = ProgressionCapMode.Gauntlet;
				}
			}
			foreach (LeaderboardEntry item3 in state.Leaderboard ?? new List<LeaderboardEntry>())
			{
				if (item3?.Key != null)
				{
					item3.Key.CapMode = ProgressionCapMode.Gauntlet;
					item3.Key.SelectedBiome = BiomeTier.BlackForest;
				}
			}
		}

		private static void MigrateLegacyRequest(ChallengeRequest request)
		{
			if (request != null)
			{
				request.CapMode = ProgressionCapMode.Gauntlet;
				request.SelectedBiome = BiomeTier.BlackForest;
			}
		}

		private static void InitializeArenaFoodSnapshots(PersistedWorldState state)
		{
			foreach (ArenaSession item in state?.InterruptedSessions ?? new List<ArenaSession>())
			{
				if (item?.ResourceSnapshot != null)
				{
					item.ResourceSnapshot.ArenaFoodPrefabNames = item.ResourceSnapshot.ArenaFoodPrefabNames ?? new List<string>();
				}
			}
		}

		private static void NormalizeAndValidate(PersistedWorldState state, long expectedWorldUid)
		{
			if (state == null || state.WorldUid == 0L || state.WorldUid != expectedWorldUid)
			{
				throw new SerializationException("World UID is missing or does not match.");
			}
			state.Arenas = state.Arenas ?? new List<ArenaDefinition>();
			state.Gates = state.Gates ?? new List<ArenaGateDefinition>();
			state.Routes = state.Routes ?? new List<PlayerArenaRoute>();
			state.Queue = state.Queue ?? new List<QueueEntry>();
			state.InterruptedSessions = state.InterruptedSessions ?? new List<ArenaSession>();
			state.Leaderboard = state.Leaderboard ?? new List<LeaderboardEntry>();
			EnsureCollectionLimits(state);
			HashSet<string> hashSet = new HashSet<string>(StringComparer.Ordinal);
			HashSet<string> hashSet2 = new HashSet<string>(StringComparer.Ordinal);
			foreach (ArenaDefinition arena in state.Arenas)
			{
				if (arena == null)
				{
					throw new SerializationException("Null arena definition.");
				}
				string text = ArenaRegistry.NormalizeId(arena.ArenaId);
				string text2 = ArenaRegistry.NormalizeName(arena.DisplayName);
				if (text == null || text2 == null || !hashSet.Add(text) || !hashSet2.Add(text2))
				{
					throw new SerializationException("Arena IDs and names must be valid and unique.");
				}
				if (!FinitePositive(arena.CombatRadius) || !FinitePositive(arena.ProtectedRadius) || arena.ProtectedRadius <= arena.CombatRadius || !Finite(arena.CorePosition))
				{
					throw new SerializationException("Arena '" + text + "' has invalid bounds.");
				}
				arena.ArenaId = text;
				arena.DisplayName = arena.DisplayName.Trim();
				arena.NormalizedName = text2;
				arena.Markers = NormalizeMarkers(arena.Markers);
				if (arena.Enabled && !ArenaRegistry.MarkersAreComplete(arena.Markers))
				{
					throw new SerializationException("Enabled arena '" + text + "' does not have a complete marker layout.");
				}
			}
			HashSet<string> hashSet3 = new HashSet<string>(StringComparer.Ordinal);
			HashSet<string> hashSet4 = new HashSet<string>(StringComparer.Ordinal);
			Dictionary<string, ArenaGateDefinition> dictionary = new Dictionary<string, ArenaGateDefinition>(StringComparer.Ordinal);
			foreach (ArenaGateDefinition gate in state.Gates)
			{
				if (gate == null)
				{
					throw new SerializationException("Null gate definition.");
				}
				string text3 = ArenaRegistry.NormalizeId(gate.GateId);
				string text4 = ArenaRegistry.NormalizeId(gate.ArenaId);
				string text5 = ArenaRegistry.NormalizeName(gate.DisplayName);
				if (text3 == null || text4 == null || text5 == null || !hashSet.Contains(text4) || !hashSet3.Add(text3) || !hashSet4.Add(text5) || !Finite(gate.Position) || !Finite(gate.RotationY))
				{
					throw new SerializationException("Gate IDs/names must be unique and target a valid arena.");
				}
				gate.GateId = text3;
				gate.ArenaId = text4;
				gate.DisplayName = gate.DisplayName.Trim();
				gate.NormalizedName = text5;
				dictionary.Add(text3, gate);
			}
			foreach (IGrouping<string, ArenaGateDefinition> item2 in from gate in state.Gates
				group gate by gate.ArenaId)
			{
				if (item2.Count((ArenaGateDefinition gate) => gate.IsFallbackEntrance) > 1)
				{
					throw new SerializationException("Arena '" + item2.Key + "' has more than one fallback entrance.");
				}
			}
			HashSet<long> hashSet5 = new HashSet<long>();
			foreach (PlayerArenaRoute route in state.Routes)
			{
				if (route == null || route.PlayerId <= 0 || !hashSet5.Add(route.PlayerId))
				{
					throw new SerializationException("Player routes must have unique positive player IDs.");
				}
				route.ArenaId = ArenaRegistry.NormalizeId(route.ArenaId);
				route.OriginGateId = ArenaRegistry.NormalizeId(route.OriginGateId);
				if (route.ArenaId == null || route.OriginGateId == null || !hashSet.Contains(route.ArenaId) || (dictionary.TryGetValue(route.OriginGateId, out var value) && !string.Equals(value.ArenaId, route.ArenaId, StringComparison.Ordinal)))
				{
					throw new SerializationException("Player route targets an invalid entrance.");
				}
				route.EnteredUtc = Utc(route.EnteredUtc);
			}
			HashSet<string> hashSet6 = new HashSet<string>(StringComparer.Ordinal);
			foreach (QueueEntry item3 in state.Queue)
			{
				if (item3?.Request == null || item3.Request.PlayerId <= 0 || item3.QueueSequence < 0)
				{
					throw new SerializationException("Queue entry is malformed.");
				}
				NormalizeRequest(item3.Request, requireIdentity: true);
				if (!hashSet.Contains(item3.Request.ArenaId) || !hashSet6.Add(item3.Request.ArenaId + ":" + item3.Request.PlayerId.ToString(CultureInfo.InvariantCulture)))
				{
					throw new SerializationException("Queue entry targets an unknown arena or duplicates a player.");
				}
				if (!string.IsNullOrWhiteSpace(item3.OriginGateId))
				{
					item3.OriginGateId = ArenaRegistry.NormalizeId(item3.OriginGateId);
					if (item3.OriginGateId == null || (dictionary.TryGetValue(item3.OriginGateId, out var value2) && !string.Equals(value2.ArenaId, item3.Request.ArenaId, StringComparison.Ordinal)))
					{
						throw new SerializationException("Queue origin gate does not target its arena.");
					}
				}
				item3.EnqueuedUtc = Utc(item3.EnqueuedUtc);
			}
			HashSet<string> hashSet7 = new HashSet<string>(StringComparer.Ordinal);
			HashSet<long> hashSet8 = new HashSet<long>();
			foreach (ArenaSession interruptedSession in state.InterruptedSessions)
			{
				ValidateInterruptedSession(interruptedSession);
				if (!hashSet.Contains(interruptedSession.ArenaId) || !hashSet7.Add(interruptedSession.SessionId) || !hashSet8.Add(interruptedSession.Request.PlayerId))
				{
					throw new SerializationException("Interrupted sessions must have unique IDs and players in a saved arena.");
				}
			}
			HashSet<string> hashSet9 = new HashSet<string>(StringComparer.Ordinal);
			for (int num = 0; num < state.Leaderboard.Count; num++)
			{
				LeaderboardEntry leaderboardEntry = NormalizeLeaderboardEntry(state.Leaderboard[num]);
				string item = KeyToken(leaderboardEntry.Key) + ":" + leaderboardEntry.PlayerId.ToString(CultureInfo.InvariantCulture);
				if (!hashSet9.Add(item))
				{
					throw new SerializationException("Leaderboard contains duplicate per-player records.");
				}
				state.Leaderboard[num] = leaderboardEntry;
			}
		}

		private static void EnsureCollectionLimits(PersistedWorldState state)
		{
			if (state.Arenas.Count > 100000 || state.Gates.Count > 100000 || state.Routes.Count > 100000 || state.Queue.Count > 100000 || state.InterruptedSessions.Count > 100000 || state.Leaderboard.Count > 100000)
			{
				throw new SerializationException("Arena state collection limit exceeded.");
			}
		}

		private static ArenaMarkerSet NormalizeMarkers(ArenaMarkerSet markers)
		{
			if (markers == null)
			{
				return null;
			}
			if (!Finite(markers.StagingPosition) || !Finite(markers.CombatantStartPosition) || !Finite(markers.HubGatePosition) || markers.EnemySpawnPositions == null || markers.EnemySpawnPositions.Count != 4 || markers.EnemySpawnPositions.Any((PositionData position) => !Finite(position)))
			{
				throw new SerializationException("Arena marker positions must be finite.");
			}
			return markers;
		}

		private static void NormalizeRequest(ChallengeRequest request, bool requireIdentity)
		{
			if (request == null)
			{
				throw new SerializationException("Challenge request is missing.");
			}
			request.RequestId = ArenaRegistry.NormalizeId(request.RequestId);
			request.ArenaId = ArenaRegistry.NormalizeId(request.ArenaId);
			if (request.RequestId == null || request.ArenaId == null || (requireIdentity && request.PlayerId <= 0) || request.Mode < ChallengeMode.BiomeLadder || request.Mode > ChallengeMode.CustomEncounter || request.CapMode < ProgressionCapMode.Gauntlet || request.CapMode > ProgressionCapMode.Biome || (request.CapMode == ProgressionCapMode.Biome && (request.SelectedBiome < BiomeTier.Meadows || request.SelectedBiome > BiomeTier.DeepNorth)))
			{
				throw new SerializationException("Challenge request fields are invalid.");
			}
			if (request.Mode == ChallengeMode.CustomEncounter)
			{
				request.CapMode = ProgressionCapMode.Gauntlet;
				request.SelectedBiome = BiomeTier.BlackForest;
			}
			else if (request.CapMode == ProgressionCapMode.Gauntlet)
			{
				request.SelectedBiome = BiomeTier.BlackForest;
			}
			request.PlayerName = (request.PlayerName ?? string.Empty).Trim();
			if (request.PlayerName.Length > 64)
			{
				throw new SerializationException("Player name is too long.");
			}
			request.RequestedUtc = Utc(request.RequestedUtc);
			if (request.Mode == ChallengeMode.CustomEncounter)
			{
				if (request.CustomSelection == null || string.IsNullOrWhiteSpace(request.CustomSelection.CreatureKey) || request.CustomSelection.CreatureKey.Length > 128 || request.CustomSelection.Quantity < 1 || request.CustomSelection.Quantity > 10 || request.CustomSelection.Stars < StarLevel.Base || request.CustomSelection.Stars > StarLevel.TwoStar)
				{
					throw new SerializationException("Custom encounter selection is invalid.");
				}
				request.CustomSelection.CreatureKey = request.CustomSelection.CreatureKey.Trim();
			}
			else
			{
				request.CustomSelection = null;
			}
		}

		private static void ValidateInterruptedSession(ArenaSession session)
		{
			if (session == null)
			{
				throw new ArgumentNullException("session");
			}
			session.SessionId = ArenaRegistry.NormalizeId(session.SessionId);
			session.ArenaId = ArenaRegistry.NormalizeId(session.ArenaId);
			bool flag = session.Phase == SessionPhase.Called || session.Phase == SessionPhase.Staging;
			if (session.SessionId == null || session.ArenaId == null || session.Request == null || session.Plan == null || (session.ResourceSnapshot == null && !flag))
			{
				throw new SerializationException("Interrupted session is incomplete.");
			}
			NormalizeRequest(session.Request, requireIdentity: true);
			if (!string.Equals(session.Request.ArenaId, session.ArenaId, StringComparison.Ordinal) || (session.ResourceSnapshot != null && session.ResourceSnapshot.PlayerId != session.Request.PlayerId))
			{
				throw new SerializationException("Interrupted session identity is inconsistent.");
			}
			session.Plan.PlanId = ArenaRegistry.NormalizeId(session.Plan.PlanId);
			session.Plan.Encounters = session.Plan.Encounters ?? new List<EncounterDefinition>();
			if (session.Plan.PlanId == null || session.Plan.Encounters.Count == 0 || session.Plan.Encounters.Count > 100000 || session.Plan.Mode != session.Request.Mode || session.Plan.CapMode != session.Request.CapMode || (session.Request.CapMode == ProgressionCapMode.Biome && session.Plan.HighestBiome != session.Request.SelectedBiome))
			{
				throw new SerializationException("Interrupted challenge plan is invalid.");
			}
			for (int i = 0; i < session.Plan.Encounters.Count; i++)
			{
				EncounterDefinition encounterDefinition = session.Plan.Encounters[i];
				if (encounterDefinition == null || encounterDefinition.Sequence != i || string.IsNullOrWhiteSpace(encounterDefinition.CreatureKey) || encounterDefinition.CreatureKey.Length > 128 || encounterDefinition.Biome < BiomeTier.Meadows || encounterDefinition.Biome > BiomeTier.DeepNorth || encounterDefinition.Stars < StarLevel.Base || encounterDefinition.Stars > StarLevel.TwoStar || encounterDefinition.Quantity < 1 || encounterDefinition.Quantity > 10 || encounterDefinition.PreparationSeconds < 0 || encounterDefinition.PreparationSeconds > 300)
				{
					throw new SerializationException("Interrupted challenge encounter is invalid.");
				}
			}
			session.SpawnedEnemyIds = session.SpawnedEnemyIds ?? new List<string>();
			if (session.EncounterIndex < 0 || session.EncounterIndex >= session.Plan.Encounters.Count || session.LivingArenaEnemyCount < 0 || session.ElapsedMilliseconds < 0 || session.SpawnedEnemyIds.Count > 100000)
			{
				throw new SerializationException("Interrupted session counters or resource collection sizes are invalid.");
			}
			if (session.ResourceSnapshot != null)
			{
				session.ResourceSnapshot.Foods = session.ResourceSnapshot.Foods ?? new List<FoodStateSnapshot>();
				session.ResourceSnapshot.ArenaFoodPrefabNames = session.ResourceSnapshot.ArenaFoodPrefabNames ?? new List<string>();
				session.ResourceSnapshot.AllowedConsumableCounts = session.ResourceSnapshot.AllowedConsumableCounts ?? new Dictionary<string, int>();
				session.ResourceSnapshot.AmmunitionCounts = session.ResourceSnapshot.AmmunitionCounts ?? new Dictionary<string, int>();
				session.ResourceSnapshot.EquipmentDurabilityBySlot = session.ResourceSnapshot.EquipmentDurabilityBySlot ?? new Dictionary<string, float>();
				if (session.ResourceSnapshot.Foods.Count > 3 || session.ResourceSnapshot.ArenaFoodPrefabNames.Count > 3 || session.ResourceSnapshot.AllowedConsumableCounts.Count > 100000 || session.ResourceSnapshot.AmmunitionCounts.Count > 100000 || session.ResourceSnapshot.EquipmentDurabilityBySlot.Count > 100000)
				{
					throw new SerializationException("Interrupted resource collection sizes are invalid.");
				}
				if (!FiniteNonNegative(session.ResourceSnapshot.RestedRemainingSeconds) || session.ResourceSnapshot.ArenaFoodPrefabNames.Any((string value) => string.IsNullOrWhiteSpace(value) || value.Length > 128) || session.ResourceSnapshot.ArenaFoodPrefabNames.Distinct<string>(StringComparer.Ordinal).Count() != session.ResourceSnapshot.ArenaFoodPrefabNames.Count)
				{
					throw new SerializationException("Interrupted arena food snapshot is invalid.");
				}
				foreach (FoodStateSnapshot food in session.ResourceSnapshot.Foods)
				{
					if (food == null || string.IsNullOrWhiteSpace(food.ItemPrefabName) || food.ItemPrefabName.Length > 128 || !FiniteNonNegative(food.RemainingSeconds) || !FiniteNonNegative(food.Health) || !FiniteNonNegative(food.Stamina) || !FiniteNonNegative(food.Eitr))
					{
						throw new SerializationException("Interrupted food snapshot is invalid.");
					}
				}
				ValidateCounts(session.ResourceSnapshot.AllowedConsumableCounts, "consumable");
				ValidateCounts(session.ResourceSnapshot.AmmunitionCounts, "ammunition");
				foreach (KeyValuePair<string, float> item in session.ResourceSnapshot.EquipmentDurabilityBySlot)
				{
					if (string.IsNullOrWhiteSpace(item.Key) || item.Key.Length > 128 || !FiniteNonNegative(item.Value))
					{
						throw new SerializationException("Interrupted equipment durability snapshot is invalid.");
					}
				}
				session.ResourceSnapshot.CapturedUtc = Utc(session.ResourceSnapshot.CapturedUtc);
			}
			session.PhaseStartedUtc = Utc(session.PhaseStartedUtc);
			session.PhaseDeadlineUtc = Utc(session.PhaseDeadlineUtc);
			session.SessionStartedUtc = Utc(session.SessionStartedUtc);
		}

		private static LeaderboardEntry NormalizeLeaderboardEntry(LeaderboardEntry entry)
		{
			if (entry == null)
			{
				throw new ArgumentNullException("entry");
			}
			if (entry.PlayerId <= 0 || entry.FurthestEncounterIndex < 0 || entry.ElapsedMilliseconds < 0 || entry.RosterRevision < 0)
			{
				throw new ArgumentException("Leaderboard result contains invalid numeric values.", "entry");
			}
			string text = (entry.PlayerName ?? string.Empty).Trim();
			if (text.Length == 0 || text.Length > 64)
			{
				throw new ArgumentException("Leaderboard player name is invalid.", "entry");
			}
			return new LeaderboardEntry
			{
				Key = NormalizeLeaderboardKey(entry.Key),
				PlayerId = entry.PlayerId,
				PlayerName = text,
				Completed = entry.Completed,
				FurthestEncounterIndex = entry.FurthestEncounterIndex,
				ElapsedMilliseconds = entry.ElapsedMilliseconds,
				RosterRevision = entry.RosterRevision,
				RecordedUtc = Utc((entry.RecordedUtc == default(DateTime)) ? DateTime.UtcNow : entry.RecordedUtc)
			};
		}

		private static LeaderboardKey NormalizeLeaderboardKey(LeaderboardKey key)
		{
			if (key == null || key.Mode < ChallengeMode.BiomeLadder || key.Mode > ChallengeMode.CustomEncounter || key.CapMode < ProgressionCapMode.Gauntlet || key.CapMode > ProgressionCapMode.Biome)
			{
				throw new ArgumentException("Leaderboard key is invalid.", "key");
			}
			if (key.Mode != ChallengeMode.CustomEncounter)
			{
				if (key.CapMode == ProgressionCapMode.Biome && (key.SelectedBiome < BiomeTier.Meadows || key.SelectedBiome > BiomeTier.DeepNorth))
				{
					throw new ArgumentException("Leaderboard biome is invalid.", "key");
				}
				return new LeaderboardKey
				{
					Mode = key.Mode,
					CapMode = key.CapMode,
					SelectedBiome = ((key.CapMode != ProgressionCapMode.Biome) ? BiomeTier.BlackForest : key.SelectedBiome),
					CustomCreatureKey = string.Empty,
					CustomStars = StarLevel.Base,
					CustomQuantity = 0
				};
			}
			string text = (key.CustomCreatureKey ?? string.Empty).Trim();
			if (text.Length == 0 || text.Length > 128 || key.CustomStars < StarLevel.Base || key.CustomStars > StarLevel.TwoStar || key.CustomQuantity < 1 || key.CustomQuantity > 10)
			{
				throw new ArgumentException("Custom leaderboard key is invalid.", "key");
			}
			return new LeaderboardKey
			{
				Mode = key.Mode,
				CapMode = ProgressionCapMode.Gauntlet,
				SelectedBiome = BiomeTier.BlackForest,
				CustomCreatureKey = text.ToLowerInvariant(),
				CustomStars = key.CustomStars,
				CustomQuantity = key.CustomQuantity
			};
		}

		private static bool IsBetter(LeaderboardEntry candidate, LeaderboardEntry existing)
		{
			if (candidate.Completed != existing.Completed)
			{
				return candidate.Completed;
			}
			if (candidate.Completed)
			{
				return candidate.ElapsedMilliseconds < existing.ElapsedMilliseconds;
			}
			if (candidate.FurthestEncounterIndex != existing.FurthestEncounterIndex)
			{
				return candidate.FurthestEncounterIndex > existing.FurthestEncounterIndex;
			}
			return candidate.ElapsedMilliseconds < existing.ElapsedMilliseconds;
		}

		private static bool KeysEqual(LeaderboardKey first, LeaderboardKey second)
		{
			if (first != null && second != null && first.Mode == second.Mode && first.CapMode == second.CapMode && first.SelectedBiome == second.SelectedBiome && first.CustomStars == second.CustomStars && first.CustomQuantity == second.CustomQuantity)
			{
				return string.Equals(first.CustomCreatureKey ?? string.Empty, second.CustomCreatureKey ?? string.Empty, StringComparison.OrdinalIgnoreCase);
			}
			return false;
		}

		private static string KeyToken(LeaderboardKey key)
		{
			string[] array = new string[11];
			int mode = (int)key.Mode;
			array[0] = mode.ToString(CultureInfo.InvariantCulture);
			array[1] = ":";
			mode = (int)key.CapMode;
			array[2] = mode.ToString(CultureInfo.InvariantCulture);
			array[3] = ":";
			mode = (int)key.SelectedBiome;
			array[4] = mode.ToString(CultureInfo.InvariantCulture);
			array[5] = ":";
			array[6] = (key.CustomCreatureKey ?? string.Empty).ToLowerInvariant();
			array[7] = ":";
			mode = (int)key.CustomStars;
			array[8] = mode.ToString(CultureInfo.InvariantCulture);
			array[9] = ":";
			array[10] = key.CustomQuantity.ToString(CultureInfo.InvariantCulture);
			return string.Concat(array);
		}

		private static bool Finite(PositionData position)
		{
			if (Finite(position.X) && Finite(position.Y))
			{
				return Finite(position.Z);
			}
			return false;
		}

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

		private static bool FinitePositive(float value)
		{
			if (Finite(value))
			{
				return value > 0f;
			}
			return false;
		}

		private static bool FiniteNonNegative(float value)
		{
			if (Finite(value))
			{
				return value >= 0f;
			}
			return false;
		}

		private static void ValidateCounts(Dictionary<string, int> values, string label)
		{
			foreach (KeyValuePair<string, int> value in values)
			{
				if (string.IsNullOrWhiteSpace(value.Key) || value.Key.Length > 128 || value.Value < 0)
				{
					throw new SerializationException("Interrupted " + label + " snapshot is invalid.");
				}
			}
		}

		private static DateTime Utc(DateTime value)
		{
			if (value == default(DateTime))
			{
				return DateTime.SpecifyKind(value, DateTimeKind.Utc);
			}
			if (value.Kind != DateTimeKind.Utc)
			{
				return value.ToUniversalTime();
			}
			return value;
		}

		private static string PreserveCorruptCopy(string path)
		{
			string text = path + ".corrupt-" + DateTime.UtcNow.ToString("yyyyMMdd-HHmmss-fff", CultureInfo.InvariantCulture);
			try
			{
				File.Copy(path, text, overwrite: false);
				return text;
			}
			catch (Exception ex)
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogWarning((object)("Could not preserve malformed ArenaGuard state '" + path + "': " + ex.Message));
				}
				return "(copy failed)";
			}
		}

		private static PersistedWorldState Empty(long worldUid)
		{
			return new PersistedWorldState
			{
				WorldUid = worldUid,
				RosterRevision = 0L,
				Arenas = new List<ArenaDefinition>(),
				Gates = new List<ArenaGateDefinition>(),
				Routes = new List<PlayerArenaRoute>(),
				Queue = new List<QueueEntry>(),
				InterruptedSessions = new List<ArenaSession>(),
				Leaderboard = new List<LeaderboardEntry>()
			};
		}

		private static PersistedWorldState Clone(PersistedWorldState source)
		{
			if (source == null)
			{
				return null;
			}
			return new PersistedWorldState
			{
				WorldUid = source.WorldUid,
				RosterRevision = source.RosterRevision,
				Arenas = (source.Arenas ?? new List<ArenaDefinition>()).Select(CopyArena).ToList(),
				Gates = (source.Gates ?? new List<ArenaGateDefinition>()).Select(CopyGate).ToList(),
				Routes = (source.Routes ?? new List<PlayerArenaRoute>()).Select(CopyRoute).ToList(),
				Queue = (source.Queue ?? new List<QueueEntry>()).Select(CopyQueueEntry).ToList(),
				InterruptedSessions = (source.InterruptedSessions ?? new List<ArenaSession>()).Select(CopySession).ToList(),
				Leaderboard = (source.Leaderboard ?? new List<LeaderboardEntry>()).Select(CopyLeaderboardEntry).ToList()
			};
		}

		private static ArenaDefinition CopyArena(ArenaDefinition source)
		{
			if (source != null)
			{
				return new ArenaDefinition
				{
					ArenaId = source.ArenaId,
					DisplayName = source.DisplayName,
					NormalizedName = source.NormalizedName,
					CorePosition = source.CorePosition,
					CombatRadius = source.CombatRadius,
					ProtectedRadius = source.ProtectedRadius,
					Markers = ((source.Markers == null) ? null : new ArenaMarkerSet
					{
						StagingPosition = source.Markers.StagingPosition,
						CombatantStartPosition = source.Markers.CombatantStartPosition,
						HubGatePosition = source.Markers.HubGatePosition,
						EnemySpawnPositions = ((source.Markers.EnemySpawnPositions == null) ? new List<PositionData>() : new List<PositionData>(source.Markers.EnemySpawnPositions))
					}),
					Enabled = source.Enabled,
					Revision = source.Revision
				};
			}
			return null;
		}

		private static ArenaGateDefinition CopyGate(ArenaGateDefinition source)
		{
			if (source != null)
			{
				return new ArenaGateDefinition
				{
					GateId = source.GateId,
					ArenaId = source.ArenaId,
					DisplayName = source.DisplayName,
					NormalizedName = source.NormalizedName,
					Position = source.Position,
					RotationY = source.RotationY,
					IsFallbackEntrance = source.IsFallbackEntrance
				};
			}
			return null;
		}

		private static PlayerArenaRoute CopyRoute(PlayerArenaRoute source)
		{
			if (source != null)
			{
				return new PlayerArenaRoute
				{
					PlayerId = source.PlayerId,
					ArenaId = source.ArenaId,
					OriginGateId = source.OriginGateId,
					EnteredUtc = source.EnteredUtc
				};
			}
			return null;
		}

		private static QueueEntry CopyQueueEntry(QueueEntry source)
		{
			if (source != null)
			{
				return new QueueEntry
				{
					Request = CopyRequest(source.Request),
					OriginGateId = source.OriginGateId,
					QueueSequence = source.QueueSequence,
					EnqueuedUtc = source.EnqueuedUtc
				};
			}
			return null;
		}

		private static ChallengeRequest CopyRequest(ChallengeRequest source)
		{
			if (source != null)
			{
				return new ChallengeRequest
				{
					RequestId = source.RequestId,
					ArenaId = source.ArenaId,
					PlayerId = source.PlayerId,
					PlayerName = source.PlayerName,
					Mode = source.Mode,
					CapMode = source.CapMode,
					SelectedBiome = source.SelectedBiome,
					RequestedUtc = source.RequestedUtc,
					CustomSelection = ((source.CustomSelection == null) ? null : new CustomEncounterSelection
					{
						CreatureKey = source.CustomSelection.CreatureKey,
						Stars = source.CustomSelection.Stars,
						Quantity = source.CustomSelection.Quantity
					})
				};
			}
			return null;
		}

		private static ArenaSession CopySession(ArenaSession source)
		{
			if (source != null)
			{
				return new ArenaSession
				{
					SessionId = source.SessionId,
					ArenaId = source.ArenaId,
					Request = CopyRequest(source.Request),
					Plan = ((source.Plan == null) ? null : new ChallengePlan
					{
						PlanId = source.Plan.PlanId,
						Mode = source.Plan.Mode,
						CapMode = source.Plan.CapMode,
						HighestBiome = source.Plan.HighestBiome,
						RosterRevision = source.Plan.RosterRevision,
						Encounters = ((source.Plan.Encounters == null) ? new List<EncounterDefinition>() : source.Plan.Encounters.Select((EncounterDefinition encounter) => (encounter != null) ? new EncounterDefinition
						{
							Sequence = encounter.Sequence,
							CreatureKey = encounter.CreatureKey,
							Biome = encounter.Biome,
							Stars = encounter.Stars,
							Quantity = encounter.Quantity,
							IsMiniboss = encounter.IsMiniboss,
							PreparationSeconds = encounter.PreparationSeconds
						} : null).ToList())
					}),
					Phase = source.Phase,
					Outcome = source.Outcome,
					EncounterIndex = source.EncounterIndex,
					LivingArenaEnemyCount = source.LivingArenaEnemyCount,
					SpawnedEnemyIds = ((source.SpawnedEnemyIds == null) ? new List<string>() : new List<string>(source.SpawnedEnemyIds)),
					ResourceSnapshot = CopyResourceSnapshot(source.ResourceSnapshot),
					PhaseStartedUtc = source.PhaseStartedUtc,
					PhaseDeadlineUtc = source.PhaseDeadlineUtc,
					SessionStartedUtc = source.SessionStartedUtc,
					ElapsedMilliseconds = source.ElapsedMilliseconds
				};
			}
			return null;
		}

		private static PlayerResourceSnapshot CopyResourceSnapshot(PlayerResourceSnapshot source)
		{
			if (source != null)
			{
				return new PlayerResourceSnapshot
				{
					PlayerId = source.PlayerId,
					Foods = ((source.Foods == null) ? new List<FoodStateSnapshot>() : source.Foods.Select((FoodStateSnapshot food) => new FoodStateSnapshot
					{
						ItemPrefabName = food.ItemPrefabName,
						RemainingSeconds = food.RemainingSeconds,
						Health = food.Health,
						Stamina = food.Stamina,
						Eitr = food.Eitr
					}).ToList()),
					RestedRemainingSeconds = source.RestedRemainingSeconds,
					ArenaFoodPrefabNames = ((source.ArenaFoodPrefabNames == null) ? new List<string>() : new List<string>(source.ArenaFoodPrefabNames)),
					AllowedConsumableCounts = ((source.AllowedConsumableCounts == null) ? new Dictionary<string, int>() : new Dictionary<string, int>(source.AllowedConsumableCounts, StringComparer.Ordinal)),
					AmmunitionCounts = ((source.AmmunitionCounts == null) ? new Dictionary<string, int>() : new Dictionary<string, int>(source.AmmunitionCounts, StringComparer.Ordinal)),
					EquipmentDurabilityBySlot = ((source.EquipmentDurabilityBySlot == null) ? new Dictionary<string, float>() : new Dictionary<string, float>(source.EquipmentDurabilityBySlot, StringComparer.Ordinal)),
					CapturedUtc = source.CapturedUtc
				};
			}
			return null;
		}

		private static LeaderboardEntry CopyLeaderboardEntry(LeaderboardEntry source)
		{
			if (source != null)
			{
				return new LeaderboardEntry
				{
					Key = ((source.Key == null) ? null : new LeaderboardKey
					{
						Mode = source.Key.Mode,
						CapMode = source.Key.CapMode,
						SelectedBiome = source.Key.SelectedBiome,
						CustomCreatureKey = source.Key.CustomCreatureKey,
						CustomStars = source.Key.CustomStars,
						CustomQuantity = source.Key.CustomQuantity
					}),
					PlayerId = source.PlayerId,
					PlayerName = source.PlayerName,
					Completed = source.Completed,
					FurthestEncounterIndex = source.FurthestEncounterIndex,
					ElapsedMilliseconds = source.ElapsedMilliseconds,
					RosterRevision = source.RosterRevision,
					RecordedUtc = source.RecordedUtc
				};
			}
			return null;
		}
	}
}
namespace ArenaGuard.Networking
{
	internal enum ArenaAdminMutationKind
	{
		RegisterArena = 1,
		RemoveArena,
		SetMarkers,
		RegisterGate,
		RemoveGate,
		SetMarker,
		RemoveMarker,
		SetAdminTerrainPermission,
		SetAdminBuildingPermission,
		SetAdminPickupPermission,
		RequestAdminStatus,
		AbortArena,
		AbortAllArenas,
		ClearArenaQueue
	}
	internal sealed class ArenaAdminMutation
	{
		internal ArenaAdminMutationKind Kind;

		internal string TargetId;

		internal ArenaDefinition Arena;

		internal ArenaMarkerSet Markers;

		internal ArenaGateDefinition Gate;

		internal int MarkerKind;

		internal int MarkerSlot;

		internal PositionData MarkerPosition;

		internal bool Enabled;
	}
	internal sealed class ArenaRequestContext
	{
		internal long PeerUid;

		internal long PlayerId;

		internal string PlayerName;

		internal bool IsAdmin;

		internal PositionData Position;
	}
	internal sealed class ArenaRpcResult
	{
		internal bool Success;

		internal string Message;

		internal static ArenaRpcResult Accepted(string message = "")
		{
			return new ArenaRpcResult
			{
				Success = true,
				Message = (message ?? string.Empty)
			};
		}

		internal static ArenaRpcResult Rejected(string message)
		{
			return new ArenaRpcResult
			{
				Success = false,
				Message = (message ?? "Request rejected.")
			};
		}
	}
	internal sealed class ArenaRpcCallbacks
	{
		internal Func<ArenaRequestContext, ChallengeRequest, ArenaRpcResult> ChallengeRequested { get; set; }

		internal Func<ArenaRequestContext, ArenaRpcResult> QueueCallAccepted { get; set; }

		internal Func<ArenaRequestContext, ArenaRpcResult> ForfeitRequested { get; set; }

		internal Func<ArenaRequestContext, ArenaRpcResult> LethalDamageReported { get; set; }

		internal Func<ArenaRequestContext, ArenaRpcResult> CombatStartArrived { get; set; }

		internal Func<ArenaRequestContext, ArenaAdminMutation, ArenaRpcResult> AdminMutationRequested { get; set; }

		internal Func<ArenaRequestContext, ArenaGateDefinition, bool, ArenaRpcResult> GateTravelAuthorizing { get; set; }

		internal Func<ArenaRequestContext, ArenaGateTravelAuthorization, bool, ArenaRpcResult> GateTravelCompleted { get; set; }

		internal Func<ArenaGateTravelAuthorization, bool> ClientGateTravelAuthorized { get; set; }

		internal Func<ArenaRequestContext, PlayerResourceSnapshot, ArenaRpcResult> ResourceSnapshotReceived { get; set; }

		internal Func<PlayerResourceSnapshot, SessionOutcome, bool> ClientResourceRestoreRequested { get; set; }

		internal Action<ArenaRequestContext, string, bool> ResourceRestoreCompleted { get; set; }

		internal Func<PositionData, float, bool> ClientMoveRequested { get; set; }

		internal Func<string, long, ArenaClientSnapshot> SnapshotRequested { get; set; }

		internal Func<LeaderboardKey, List<LeaderboardEntry>> LeaderboardRequested { get; set; }

		internal Action<ArenaClientSnapshot> ClientSnapshotReceived { get; set; }

		internal Action<string> ClientArenaRemoved { get; set; }

		internal Action<ArenaGateDefinition> ClientGateConfigurationReceived { get; set; }

		internal Action<LeaderboardKey, List<LeaderboardEntry>> ClientLeaderboardReceived { get; set; }

		internal Action<bool, string> ClientActionResultReceived { get; set; }

		internal Action<long> ServerPeerConnected { get; set; }
	}
	internal sealed class ArenaGateTravelAuthorization
	{
		internal string TravelToken;

		internal string GateId;

		internal string ArenaId;

		internal PositionData Destination;

		internal float RotationY;

		internal bool Returning;
	}
	internal static class ArenaRpc
	{
		private sealed class PendingGateTravel
		{
			internal ArenaRequestContext Context;

			internal ArenaGateTravelAuthorization Authorization;

			internal DateTime ExpiresUtc;
		}

		private sealed class PendingResourceRestore
		{
			internal ArenaRequestContext Context;

			internal DateTime ExpiresUtc;
		}

		private const int ProtocolVersion = 8;

		private const int MaximumPackageBytes = 1048576;

		private const int MaximumLeaderboardEntries = 500;

		private const int MaximumStringLength = 256;

		private const int MaximumResourceEntries = 1024;

		private const int MaximumAppliedRestoreKeys = 128;

		private const float MaximumGateUseDistance = 10f;

		private static readonly TimeSpan GateTravelTimeout = TimeSpan.FromSeconds(30.0);

		private const string ChallengeRpc = "jg224.arenaguard.RequestChallenge";

		private const string AcceptRpc = "jg224.arenaguard.AcceptQueueCall";

		private const string ForfeitRpc = "jg224.arenaguard.RequestForfeit";

		private const string LethalDamageRpc = "jg224.arenaguard.ReportLethalDamage";

		private const string CombatStartArrivalRpc = "jg224.arenaguard.CombatStartArrived";

		private const string AdminRpc = "jg224.arenaguard.RequestAdminMutation";

		private const string SnapshotRpc = "jg224.arenaguard.ArenaSnapshot";

		private const string ArenaRemovedRpc = "jg224.arenaguard.ArenaRemoved";

		private const string GateConfigurationRpc = "jg224.arenaguard.GateConfiguration";

		private const string LeaderboardRequestRpc = "jg224.arenaguard.RequestLeaderboard";

		private const string LeaderboardResponseRpc = "jg224.arenaguard.Leaderboard";

		private const string ResultRpc = "jg224.arenaguard.ActionResult";

		private const string GateTravelRequestRpc = "jg224.arenaguard.RequestGateTravel";

		private const string GateTravelAuthorizationRpc = "jg224.arenaguard.AuthorizeGateTravel";

		private const string GateTravelAcknowledgementRpc = "jg224.arenaguard.AcknowledgeGateTravel";

		private const string ResourceSnapshotRpc = "jg224.arenaguard.SubmitResourceSnapshot";

		private const string ResourceRestoreRpc = "jg224.arenaguard.RestoreResources";

		private const string ResourceRestoreAcknowledgementRpc = "jg224.arenaguard.AcknowledgeResourceRestore";

		private const string MovePlayerRpc = "jg224.arenaguard.MovePlayer";

		private static ZRoutedRpc _registeredInstance;

		private static Action<long> _newPeerHandler;

		private static ArenaRpcCallbacks _callbacks = new ArenaRpcCallbacks();

		private static readonly Dictionary<string, PendingGateTravel> PendingGateTravels = new Dictionary<string, PendingGateTravel>(StringComparer.Ordinal);

		private static readonly Dictionary<string, PendingResourceRestore> PendingResourceRestores = new Dictionary<string, PendingResourceRestore>(StringComparer.Ordinal);

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

		private static readonly Queue<string> AppliedResourceRestoreOrder = new Queue<string>();

		internal static void Configure(ArenaRpcCallbacks callbacks)
		{
			_callbacks = callbacks ?? new ArenaRpcCallbacks();
		}

		internal static void Register()
		{
			Register(ZRoutedRpc.instance);
		}

		internal static void Register(ZRoutedRpc rpc)
		{
			if (rpc == null)
			{
				return;
			}
			if (_registeredInstance != rpc)
			{
				DetachPeerHook();
				rpc.Register<ZPackage>("jg224.arenaguard.RequestChallenge", (Action<long, ZPackage>)OnChallengeRequest);
				rpc.Register<ZPackage>("jg224.arenaguard.AcceptQueueCall", (Action<long, ZPackage>)OnAcceptQueueCall);
				rpc.Register<ZPackage>("jg224.arenaguard.RequestForfeit", (Action<long, ZPackage>)OnForfeitRequest);
				rpc.Register<ZPackage>("jg224.arenaguard.ReportLethalDamage", (Action<long, ZPackage>)OnLethalDamageReport);
				rpc.Register<ZPackage>("jg224.arenaguard.CombatStartArrived", (Action<long, ZPackage>)OnCombatStartArrival);
				rpc.Register<ZPackage>("jg224.arenaguard.RequestAdminMutation", (Action<long, ZPackage>)OnAdminMutation);
				rpc.Register<ZPackage>("jg224.arenaguard.ArenaSnapshot", (Action<long, ZPackage>)OnArenaSnapshot);
				rpc.Register<ZPackage>("jg224.arenaguard.ArenaRemoved", (Action<long, ZPackage>)OnArenaRemoved);
				rpc.Register<ZPackage>("jg224.arenaguard.GateConfiguration", (Action<long, ZPackage>)OnGateConfiguration);
				rpc.Register<ZPackage>("jg224.arenaguard.RequestLeaderboard", (Action<long, ZPackage>)OnLeaderboardRequest);
				rpc.Register<ZPackage>("jg224.arenaguard.Leaderboard", (Action<long, ZPackage>)OnLeaderboardResponse);
				rpc.Register<ZPackage>("jg224.arenaguard.ActionResult", (Action<long, ZPackage>)OnActionResult);
				rpc.Register<ZPackage>("jg224.arenaguard.RequestGateTravel", (Action<long, ZPackage>)OnGateTravelRequest);
				rpc.Register<ZPackage>("jg224.arenaguard.AuthorizeGateTravel", (Action<long, ZPackage>)OnGateTravelAuthorization);
				rpc.Register<ZPackage>("jg224.arenaguard.AcknowledgeGateTravel", (Action<long, ZPackage>)OnGateTravelAcknowledgement);
				rpc.Register<ZPackage>("jg224.arenaguard.SubmitResourceSnapshot", (Action<long, ZPackage>)OnResourceSnapshot);
				rpc.Register<ZPackage>("jg224.arenaguard.RestoreResources", (Action<long, ZPackage>)OnResourceRestore);
				rpc.Register<ZPackage>("jg224.arenaguard.AcknowledgeResourceRestore", (Action<long, ZPackage>)OnResourceRestoreAcknowledgement);
				rpc.Register<ZPackage>("jg224.arenaguard.MovePlayer", (Action<long, ZPackage>)OnMovePlayer);
				_registeredInstance = rpc;
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogInfo((object)$"Registered ArenaGuard routed RPC protocol {8}.");
				}
			}
			DetachPeerHook();
			if ((Object)(object)ZNet.instance != (Object)null && ZNet.instance.IsServer())
			{
				_newPeerHandler = OnNewPeer;
				rpc.m_onNewPeer = (Action<long>)Delegate.Combine(rpc.m_onNewPeer, _newPeerHandler);
			}
		}

		internal static void RequestChallenge(ChallengeRequest request)
		{
			if (!TryPrepareLocalRequest(out var znet, out var rpc))
			{
				return;
			}
			ChallengeRequest request2 = SanitizeClientChallenge(request);
			if (znet.IsServer())
			{
				if (TryResolveLocalContext(out var context))
				{
					request2 = StampIdentity(request2, context);
					ReceiveLocalResult(ValidateChallengeLocation(context, request2, out var rejection) ? Invoke(_callbacks.ChallengeRequested, context, request2) : ArenaRpcResult.Rejected(rejection));
				}
			}
			else
			{
				ZPackage val = NewPackage();
				WriteChallengeRequest(val, request2, includeIdentity: false);
				rpc.InvokeRoutedRPC("jg224.arenaguard.RequestChallenge", new object[1] { val });
			}
		}

		internal static void AcceptQueueCall(string requestId)
		{
			AcceptQueueCall();
		}

		internal static void AcceptQueueCall()
		{
			if (!TryPrepareLocalRequest(out var znet, out var rpc))
			{
				return;
			}
			if (znet.IsServer())
			{
				if (TryResolveLocalContext(out var context))
				{
					ReceiveLocalResult(Invoke(_callbacks.QueueCallAccepted, context));
				}
			}
			else
			{
				rpc.InvokeRoutedRPC("jg224.arenaguard.AcceptQueueCall", new object[1] { NewPackage() });
			}
		}

		internal static void RequestForfeit(string sessionId)
		{
			RequestForfeit();
		}

		internal static void RequestForfeit()
		{
			if (!TryPrepareLocalRequest(out var znet, out var rpc))
			{
				return;
			}
			if (znet.IsServer())
			{
				if (TryResolveLocalContext(out var context))
				{
					ReceiveLocalResult(Invoke(_callbacks.ForfeitRequested, context));
				}
			}
			else
			{
				rpc.InvokeRoutedRPC("jg224.arenaguard.RequestForfeit", new object[1] { NewPackage() });
			}
		}

		internal static void ReportLethalDamage()
		{
			if (!TryPrepareLocalRequest(out var znet, out var rpc))
			{
				return;
			}
			if (znet.IsServer())
			{
				if (TryResolveLocalContext(out var context))
				{
					ReceiveLocalResult(Invoke(_callbacks.LethalDamageReported, context));
				}
			}
			else
			{
				rpc.InvokeRoutedRPC("jg224.arenaguard.ReportLethalDamage", new object[1] { NewPackage() });
			}
		}

		internal static void ReportCombatStartArrival()
		{
			if (!TryPrepareLocalRequest(out var znet, out var rpc))
			{
				return;
			}
			if (znet.IsServer())
			{
				if (TryResolveLocalContext(out var context))
				{
					ReceiveLocalResult(Invoke(_callbacks.CombatStartArrived, context));
				}
			}
			else
			{
				rpc.InvokeRoutedRPC("jg224.arenaguard.CombatStartArrived", new object[1] { NewPackage() });
			}
		}

		internal static void RequestAdminMutation(ArenaAdminMutation mutation)
		{
			if (mutation == null)
			{
				throw new ArgumentNullException("mutation");
			}
			if (!TryPrepareLocalRequest(out var znet, out var rpc))
			{
				return;
			}
			if (znet.IsServer())
			{
				if (!TryResolveLocalContext(out var context))
				{
					ReceiveLocalResult(ArenaRpcResult.Rejected("ArenaGuard could not resolve the local administrator identity."));
					return;
				}
				ValidateAdminMutation(mutation);
				ReceiveLocalResult(InvokeAdmin(context, mutation));
			}
			else
			{
				ZPackage val = NewPackage();
				WriteAdminMutation(val, mutation);
				rpc.InvokeRoutedRPC("jg224.arenaguard.RequestAdminMutation", new object[1] { val });
			}
		}

		internal static bool RequestGateTravel(string gateId, bool returning)
		{
			gateId = (returning ? string.Empty : RequireId(gateId, "gate ID"));
			if (!TryPrepareLocalRequest(out var znet, out var rpc))
			{
				return false;
			}
			if (znet.IsServer())
			{
				if (!TryResolveLocalContext(out var context))
				{
					return false;
				}
				ArenaGateTravelAuthorization authorization;
				ArenaRpcResult arenaRpcResult = TryAuthorizeGateTravel(context, gateId, returning, out authorization);
				if (!arenaRpcResult.Success)
				{
					ReceiveLocalResult(arenaRpcResult);
					return false;
				}
				CompleteLocalGateTravel(context, authorization);
				return true;
			}
			ZPackage val = NewPackage();
			val.Write(returning);
			val.Write(gateId);
			rpc.InvokeRoutedRPC("jg224.arenaguard.RequestGateTravel", new object[1] { val });
			return true;
		}

		internal static void SubmitResourceSnapshot(PlayerResourceSnapshot snapshot)
		{
			PlayerResourceSnapshot playerResourceSnapshot = ValidateAndCopyResourceSnapshot(snapshot, 0L, requireIdentity: false);
			if (!TryPrepareLocalRequest(out var znet, out var rpc))
			{
				return;
			}
			if (znet.IsServer())
			{
				if (TryResolveLocalContext(out var context))
				{
					playerResourceSnapshot.PlayerId = context.PlayerId;
					playerResourceSnapshot.CapturedUtc = DateTime.UtcNow;
					ReceiveLocalResult(_callbacks.ResourceSnapshotReceived?.Invoke(context, playerResourceSnapshot) ?? ArenaRpcResult.Rejected("Arena resource capture is not ready."));
				}
			}
			else
			{
				ZPackage val = NewPackage();
				WriteResourceSnapshot(val, playerResourceSnapshot, includeIdentity: false);
				rpc.InvokeRoutedRPC("jg224.arenaguard.SubmitResourceSnapshot", new object[1] { val });
			}
		}

		internal static bool SendResourceRestore(long playerId, PlayerResourceSnapshot snapshot, SessionOutcome outcome)
		{
			if (playerId <= 0 || outcome <= SessionOutcome.None || outcome > SessionOutcome.RuntimeError)
			{
				return false;
			}
			PlayerResourceSnapshot playerResourceSnapshot = ValidateAndCopyResourceSnapshot(snapshot, playerId, requireIdentity: true);
			RemoveExpiredResourceRestores();
			ZNet instance = ZNet.instance;
			ZRoutedRpc instance2 = ZRoutedRpc.instance;
			if ((Object)(object)instance == (Object)null || instance2 == null || !instance.IsServer())
			{
				return false;
			}
			string text = Guid.NewGuid().ToString("N").ToLowerInvariant();
			if ((Object)(object)Player.m_localPlayer != (Object)null && Player.m_localPlayer.GetPlayerID() == playerId)
			{
				bool flag = _callbacks.ClientResourceRestoreRequested?.Invoke(playerResourceSnapshot, outcome) ?? false;
				if (TryResolveLocalContext(out var context))
				{
					_callbacks.ResourceRestoreCompleted?.Invoke(context, text, flag);
				}
				return flag;
			}
			foreach (ZNetPeer connectedPeer in instance.GetConnectedPeers())
			{
				if (TryResolvePeer(connectedPeer, out var context2) && context2.PlayerId == playerId)
				{
					if (PendingResourceRestores.Values.Any((PendingResourceRestore pending) => pending.Context.PlayerId == context2.PlayerId && pending.Context.PeerUid == context2.PeerUid))
					{
						return true;
					}
					PendingResourceRestores[text] = new PendingResourceRestore
					{
						Context = context2,
						ExpiresUtc = DateTime.UtcNow.Add(GateTravelTimeout)
					};
					ZPackage val = NewPackage();
					val.Write(text);
					val.Write((int)outcome);
					WriteResourceSnapshot(val, playerResourceSnapshot, includeIdentity: true);
					instance2.InvokeRoutedRPC(connectedPeer.m_uid, "jg224.arenaguard.RestoreResources", new object[1] { val });
					return true;
				}
			}
			return false;
		}

		internal static bool SendPlayerMove(long playerId, PositionData destination, float rotationY = 0f)
		{
			if (playerId <= 0 || !Finite(destination.X) || !Finite(destination.Y) || !Finite(destination.Z) || !Finite(rotationY))
			{
				return false;
			}
			ZNet instance = ZNet.instance;
			ZRoutedRpc instance2 = ZRoutedRpc.instance;
			if ((Object)(object)instance == (Object)null || instance2 == null || !instance.IsServer())
			{
				return false;
			}
			if ((Object)(object)Player.m_localPlayer != (Object)null && Player.m_localPlayer.GetPlayerID() == playerId)
			{
				return _callbacks.ClientMoveRequested?.Invoke(destination, rotationY) ?? false;
			}
			foreach (ZNetPeer connectedPeer in instance.GetConnectedPeers())
			{
				if (TryResolvePeer(connectedPeer, out var context) && context.PlayerId == playerId)
				{
					ZPackage val = NewPackage();
					WritePosition(val, destination);
					val.Write(rotationY);
					instance2.InvokeRoutedRPC(connectedPeer.m_uid, "jg224.arenaguard.MovePlayer", new object[1] { val });
					return true;
				}
			}
			return false;
		}

		internal static void RequestLeaderboard(LeaderboardKey key)
		{
			LeaderboardKey leaderboardKey = NormalizeLeaderboardKey(key);
			if (TryPrepareLocalRequest(out var znet, out var rpc))
			{
				if (znet.IsServer())
				{
					List<LeaderboardEntry> arg = _callbacks.LeaderboardRequested?.Invoke(leaderboardKey) ?? new List<LeaderboardEntry>();
					_callbacks.ClientLeaderboardReceived?.Invoke(leaderboardKey, arg);
					return;
				}
				ZPackage val = NewPackage();
				WriteLeaderboardKey(val, leaderboardKey);
				rpc.InvokeRoutedRPC("jg224.arenaguard.RequestLeaderboard", new object[1] { val });
			}
		}

		internal static void BroadcastArenaState(string arenaId)
		{
			arenaId = ArenaRegistry.NormalizeId(arenaId);
			ZNet instance = ZNet.instance;
			ZRoutedRpc instance2 = ZRoutedRpc.instance;
			if (arenaId == null || (Object)(object)instance == (Object)null || instance2 == null || !instance.IsServer())
			{
				return;
			}
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer != (Object)null)
			{
				ArenaClientSnapshot arenaClientSnapshot = _callbacks.SnapshotRequested?.Invoke(arenaId, localPlayer.GetPlayerID());
				if (arenaClientSnapshot != null)
				{
					_callbacks.ClientSnapshotReceived?.Invoke(arenaClientSnapshot);
				}
			}
			foreach (ZNetPeer connectedPeer in instance.GetConnectedPeers())
			{
				if (connectedPeer != null)
				{
					SendArenaStateToPeer(connectedPeer.m_uid, arenaId);
				}
			}
		}

		internal static void BroadcastArenaRemoval(string arenaId)
		{
			arenaId = RequireId(arenaId, "arena ID");
			ZNet instance = ZNet.instance;
			ZRoutedRpc instance2 = ZRoutedRpc.instance;
			if ((Object)(object)instance == (Object)null || instance2 == null || !instance.IsServer())
			{
				return;
			}
			_callbacks.ClientArenaRemoved?.Invoke(arenaId);
			foreach (ZNetPeer connectedPeer in instance.GetConnectedPeers())
			{
				if (connectedPeer != null)
				{
					ZPackage val = NewPackage();
					val.Write(arenaId);
					instance2.InvokeRoutedRPC(connectedPeer.m_uid, "jg224.arenaguard.ArenaRemoved", new object[1] { val });
				}
			}
		}

		internal static void BroadcastGateConfiguration(ArenaGateDefinition gate)
		{
			ArenaGateDefinition arenaGateDefinition = ValidateAndCopyGate(gate);
			ZNet instance = ZNet.instance;
			ZRoutedRpc instance2 = ZRoutedRpc.instance;
			if ((Object)(object)instance == (Object)null || instance2 == null || !instance.IsServer())
			{
				return;
			}
			_callbacks.ClientGateConfigurationReceived?.Invoke(arenaGateDefinition);
			foreach (ZNetPeer connectedPeer in instance.GetConnectedPeers())
			{
				if (connectedPeer != null)
				{
					ZPackage val = NewPackage();
					WriteGate(val, arenaGateDefinition);
					instance2.InvokeRoutedRPC(connectedPeer.m_uid, "jg224.arenaguard.GateConfiguration", new object[1] { val });
				}
			}
		}

		private static void SendArenaStateToPeer(long peerUid, string arenaId)
		{
			ZNet instance = ZNet.instance;
			ZRoutedRpc instance2 = ZRoutedRpc.instance;
			if (!((Object)(object)instance == (Object)null) && instance2 != null && instance.IsServer())
			{
				ArenaRequestContext context;
				long arg = (TryResolvePeer(instance.GetPeer(peerUid), out context) ? context.PlayerId : 0);
				ArenaClientSnapshot arenaClientSnapshot = _callbacks.SnapshotRequested?.Invoke(arenaId, arg);
				if (arenaClientSnapshot != null)
				{
					ZPackage val = NewPackage();
					WriteArenaSnapshot(val, arenaClientSnapshot);
					instance2.InvokeRoutedRPC(peerUid, "jg224.arenaguard.ArenaSnapshot", new object[1] { val });
				}
			}
		}

		internal static void SendLeaderboard(long playerId, LeaderboardKey key)
		{
			if (playerId <= 0)
			{
				return;
			}
			LeaderboardKey leaderboardKey = NormalizeLeaderboardKey(key);
			List<LeaderboardEntry> list = (_callbacks.LeaderboardRequested?.Invoke(leaderboardKey) ?? new List<LeaderboardEntry>()).Take(500).ToList();
			ZNet instance = ZNet.instance;
			ZRoutedRpc instance2 = ZRoutedRpc.instance;
			if ((Object)(object)instance == (Object)null || instance2 == null || !instance.IsServer())
			{
				return;
			}
			if ((Object)(object)Player.m_localPlayer != (Object)null && Player.m_localPlayer.GetPlayerID() == playerId)
			{
				_callbacks.ClientLeaderboardReceived?.Invoke(leaderboardKey, list);
				return;
			}
			foreach (ZNetPeer connectedPeer in instance.GetConnectedPeers())
			{
				if (!TryResolvePeer(connectedPeer, out var context) || context.PlayerId != playerId)
				{
					continue;
				}
				ZPackage val = NewPackage();
				WriteLeaderboardKey(val, leaderboardKey);
				val.Write(list.Count);
				foreach (LeaderboardEntry item in list)
				{
					WriteLeaderboardEntry(val, item);
				}
				instance2.InvokeRoutedRPC(connectedPeer.m_uid, "jg224.arenaguard.Leaderboard", new object[1] { val });
				break;
			}
		}

		internal static void Shutdown()
		{
			foreach (PendingGateTravel item in PendingGateTravels.Values.ToList())
			{
				try
				{
					CompleteGateTravel(item.Context, item.Authorization, accepted: false);
				}
				catch (Exception ex)
				{
					ManualLogSource log = Plugin.Log;
					if (log != null)
					{
						log.LogWarning((object)("Could not cancel pending gate travel during shutdown: " + ex.Message));
					}
				}
			}
			PendingGateTravels.Clear();
			PendingResourceRestores.Clear();
			AppliedResourceRestoreKeys.Clear();
			AppliedResourceRestoreOrder.Clear();
			DetachPeerHook();
			_registeredInstance = null;
			_callbacks = new ArenaRpcCallbacks();
		}

		private static void OnNewPeer(long peerUid)
		{
			if (_callbacks.ServerPeerConnected != null)
			{
				_callbacks.ServerPeerConnected(peerUid);
				return;
			}
			foreach (ArenaDefinition item in ArenaRegistry.GetArenaSnapshot())
			{
				SendArenaStateToPeer(peerUid, item.ArenaId);
			}
		}

		private static void OnChallengeRequest(long sender, ZPackage package)
		{
			if (!TryBeginServerRequest(sender, package, out var context))
			{
				return;
			}
			try
			{
				ChallengeRequest request = ReadChallengeRequest(package, includeIdentity: false);
				RequireConsumed(package);
				request = StampIdentity(request, context);
				if (!ValidateChallengeLocation(context, request, out var rejection))
				{
					throw new InvalidOperationException(rejection);
				}
				SendResult(sender, Invoke(_callbacks.ChallengeRequested, context, request));
			}
			catch (Exception exception)
			{
				Reject(sender, "challenge request", exception);
			}
		}

		private static void OnAcceptQueueCall(long sender, ZPackage package)
		{
			if (!TryBeginServerRequest(sender, package, out var context))
			{
				return;
			}
			try
			{
				RequireConsumed(package);
				SendResult(sender, Invoke(_callbacks.QueueCallAccepted, context));
			}
			catch (Exception exception)
			{
				Reject(sender, "queue acceptance", exception);
			}
		}

		private static void OnForfeitRequest(long sender, ZPackage package)
		{
			if (!TryBeginServerRequest(sender, package, out var context))
			{
				return;
			}
			try
			{
				RequireConsumed(package);
				SendResult(sender, Invoke(_callbacks.ForfeitRequested, context));
			}
			catch (Exception exception)
			{
				Reject(sender, "forfeit request", exception);
			}
		}

		private static void OnLethalDamageReport(long sender, ZPackage package)
		{
			if (!TryBeginServerRequest(sender, package, out var context))
			{
				return;
			}
			try
			{
				RequireConsumed(package);
				SendResult(sender, Invoke(_callbacks.LethalDamageReported, context));
			}
			catch (Exception exception)
			{
				Reject(sender, "lethal damage report", exception);
			}
		}

		private static void OnCombatStartArrival(long sender, ZPackage package)
		{
			if (!TryBeginServerRequest(sender, package, out var context))
			{
				return;
			}
			try
			{
				RequireConsumed(package);
				SendResult(sender, Invoke(_callbacks.CombatStartArrived, context));
			}
			catch (Exception exception)
			{
				Reject(sender, "combat start arrival", exception);
			}
		}

		private static void OnAdminMutation(long sender, ZPackage package)
		{
			if (!TryBeginServerRequest(sender, package, out var context))
			{
				return;
			}
			try
			{
				if (!context.IsAdmin)
				{
					throw new UnauthorizedAccessException("Only a server administrator may change an arena.");
				}
				ArenaAdminMutation mutation = ReadAdminMutation(package);
				RequireConsumed(package);
				ValidateAdminMutation(mutation);
				SendResult(sender, InvokeAdmin(context, mutation));
			}
			catch (Exception exception)
			{
				Reject(sender, "administrator mutation", exception);
			}
		}

		private static void OnLeaderboardRequest(long sender, ZPackage package)
		{
			if (!TryBeginServerRequest(sender, package, out var context))
			{
				return;
			}
			try
			{
				LeaderboardKey key = ReadLeaderboardKey(package);
				RequireConsumed(package);
				SendLeaderboard(context.PlayerId, key);
			}
			catch (Exception exception)
			{
				Reject(sender, "leaderboard request", exception);
			}
		}

		private static void OnArenaSnapshot(long sender, ZPackage package)
		{
			if (!TryBeginClientResponse(sender, package))
			{
				return;
			}
			try
			{
				ArenaClientSnapshot obj = ReadArenaSnapshot(package);
				RequireConsumed(package);
				_callbacks.ClientSnapshotReceived?.Invoke(obj);
			}
			catch (Exception arg)
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogError((object)$"Rejected invalid arena snapshot: {arg}");
				}
			}
		}

		private static void OnArenaRemoved(long sender, ZPackage package)
		{
			if (!TryBeginClientResponse(sender, package))
			{
				return;
			}
			try
			{
				string obj = RequireId(ReadString(package, 64), "arena ID");
				RequireConsumed(package);
				_callbacks.ClientArenaRemoved?.Invoke(obj);
			}
			catch (Exception arg)
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogError((object)$"Rejected invalid arena removal: {arg}");
				}
			}
		}

		private static void OnGateConfiguration(long sender, ZPackage package)
		{
			if (!TryBeginClientResponse(sender, package))
			{
				return;
			}
			try
			{
				ArenaGateDefinition obj = ReadGate(package);
				RequireConsumed(package);
				_callbacks.ClientGateConfigurationReceived?.Invoke(obj);
			}
			catch (Exception arg)
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogError((object)$"Rejected invalid gate configuration: {arg}");
				}
			}
		}

		private static void OnLeaderboardResponse(long sender, ZPackage package)
		{
			if (!TryBeginClientResponse(sender, package))
			{
				return;
			}
			try
			{
				LeaderboardKey leaderboardKey = ReadLeaderboardKey(package);
				int num = package.ReadInt();
				if (num < 0 || num > 500)
				{
					throw new InvalidOperationException("Leaderboard result count is invalid.");
				}
				List<LeaderboardEntry> list = new List<LeaderboardEntry>(num);
				for (int i = 0; i < num; i++)
				{
					list.Add(ReadLeaderboardEntry(package, leaderboardKey));
				}
				RequireConsumed(package);
				_callbacks.ClientLeaderboardReceived?.Invoke(leaderboardKey, list);
			}
			catch (Exception arg)
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogError((object)$"Rejected invalid leaderboard response: {arg}");
				}
			}
		}

		private static void OnActionResult(long sender, ZPackage package)
		{
			if (!TryBeginClientResponse(sender, package))
			{
				return;
			}
			try
			{
				bool arg = package.ReadBool();
				string arg2 = ReadString(package, 256);
				RequireConsumed(package);
				_callbacks.ClientActionResultReceived?.Invoke(arg, arg2);
			}
			catch (Exception arg3)
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogError((object)$"Rejected invalid arena action result: {arg3}");
				}
			}
		}

		private static void OnGateTravelRequest(long sender, ZPackage package)
		{
			if (!TryBeginServerRequest(sender, package, out var context))
			{
				return;
			}
			try
			{
				bool flag = package.ReadBool();
				string text = ReadString(package, 64);
				RequireConsumed(package);
				if (!flag)
				{
					text = RequireId(text, "gate ID");
				}
				else if (text.Length != 0)
				{
					throw new InvalidOperationException("A return request cannot select a destination gate.");
				}
				ArenaGateTravelAuthorization authorization;
				ArenaRpcResult arenaRpcResult = TryAuthorizeGateTravel(context, text, flag, out authorization);
				if (!arenaRpcResult.Success)
				{
					SendResult(sender, arenaRpcResult);
					return;
				}
				ZPackage val = NewPackage();
				WriteGateTravelAuthorization(val, authorization);
				ZRoutedRpc instance = ZRoutedRpc.instance;
				if (instance != null)
				{
					instance.InvokeRoutedRPC(sender, "jg224.arenaguard.AuthorizeGateTravel", new object[1] { val });
				}
			}
			catch (Exception exception)
			{
				Reject(sender, "gate travel request", exception);
			}
		}

		private static void OnGateTravelAuthorization(long sender, ZPackage package)
		{
			if (!TryBeginClientResponse(sender, package))
			{
				return;
			}
			ArenaGateTravelAuthorization arenaGateTravelAuthorization = null;
			bool flag = false;
			try
			{
				arenaGateTravelAuthorization = ReadGateTravelAuthorization(package);
				RequireConsumed(package);
				flag = _callbacks.ClientGateTravelAuthorized?.Invoke(arenaGateTravelAuthorization) ?? false;
			}
			catch (Exception arg)
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogError((object)$"Could not apply ArenaGuard gate destination: {arg}");
				}
			}
			if (arenaGateTravelAuthorization != null)
			{
				ZRoutedRpc instance = ZRoutedRpc.instance;
				if (instance != null)
				{
					ZPackage val = NewPackage();
					val.Write(arenaGateTravelAuthorization.TravelToken);
					val.Write(flag);
					instance.InvokeRoutedRPC("jg224.arenaguard.AcknowledgeGateTravel", new object[1] { val });
				}
			}
		}

		private static void OnGateTravelAcknowledgement(long sender, ZPackage package)
		{
			if (!TryBeginServerRequest(sender, package, out var context))
			{
				return;
			}
			try
			{
				string key = RequireId(ReadString(package, 64), "travel token");
				bool accepted = package.ReadBool();
				RequireConsumed(package);
				RemoveExpiredGateTravels();
				if (!PendingGateTravels.TryGetValue(key, out var value) || value.Context.PlayerId != context.PlayerId || value.Context.PeerUid != context.PeerUid)
				{
					throw new InvalidOperationException("Gate travel authorization is missing, expired, or belongs to another player.");
				}
				PendingGateTravels.Remove(key);
				ArenaRpcResult result = CompleteGateTravel(context, value.Authorization, accepted);
				SendResult(sender, result);
			}
			catch (Exception exception)
			{
				Reject(sender, "gate travel acknowledgement", exception);
			}
		}

		private static void OnResourceSnapshot(long sender, ZPackage package)
		{
			if (!TryBeginServerRequest(sender, package, out var context))
			{
				return;
			}
			try
			{
				PlayerResourceSnapshot playerResourceSnapshot = ReadResourceSnapshot(package, includeIdentity: false);
				RequireConsumed(package);
				playerResourceSnapshot.PlayerId = context.PlayerId;
				playerResourceSnapshot.CapturedUtc = DateTime.UtcNow;
				ArenaRpcResult result = _callbacks.ResourceSnapshotReceived?.Invoke(context, playerResourceSnapshot) ?? ArenaRpcResult.Rejected("Arena resource capture is not ready.");
				SendResult(sender, result);
			}
			catch (Exception exception)
			{
				Reject(sender, "resource snapshot", exception);
			}
		}

		private static void OnResourceRestore(long sender, ZPackage package)
		{
			if (!TryBeginClientResponse(sender, package))
			{
				return;
			}
			string text = null;
			bool flag = false;
			try
			{
				text = RequireId(ReadString(package, 64), "resource restore token");
				SessionOutcome sessionOutcome = (SessionOutcome)package.ReadInt();
				if (sessionOutcome <= SessionOutcome.None || sessionOutcome > SessionOutcome.RuntimeError)
				{
					throw new InvalidOperationException("Resource restore outcome is invalid.");
				}
				PlayerResourceSnapshot playerResourceSnapshot = ReadResourceSnapshot(package, includeIdentity: true);
				RequireConsumed(package);
				Player localPlayer = Player.m_localPlayer;
				if ((Object)(object)localPlayer == (Object)null || localPlayer.GetPlayerID() != playerResourceSnapshot.PlayerId)
				{
					throw new InvalidOperationException("Resource restore targets another character.");
				}
				string text2 = ResourceRestoreKey(playerResourceSnapshot);
				flag = AppliedResourceRestoreKeys.Contains(text2) || (_callbacks.ClientResourceRestoreRequested?.Invoke(playerResourceSnapshot, sessionOutcome) ?? false);
				if (flag)
				{
					RememberAppliedResourceRestore(text2);
				}
			}
			catch (Exception arg)
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogError((object)$"Could not apply ArenaGuard resource restore: {arg}");
				}
			}
			if (text != null)
			{
				ZRoutedRpc instance = ZRoutedRpc.instance;
				if (instance != null)
				{
					ZPackage val = NewPackage();
					val.Write(text);
					val.Write(flag);
					instance.InvokeRoutedRPC("jg224.arenaguard.AcknowledgeResourceRestore", new object[1] { val });
				}
			}
		}

		private static void OnResourceRestoreAcknowledgement(long sender, ZPackage package)
		{
			if (!TryBeginServerRequest(sender, package, out var context))
			{
				return;
			}
			try
			{
				string text = RequireId(ReadString(package, 64), "resource restore token");
				bool arg = package.ReadBool();
				RequireConsumed(package);
				RemoveExpiredResourceRestores();
				if (!PendingResourceRestores.TryGetValue(text, out var value) || value.Context.PlayerId != context.PlayerId || value.Context.PeerUid != context.PeerUid)
				{
					throw new InvalidOperationException("Resource restore is missing, expired, or belongs to another character.");
				}
				PendingResourceRestores.Remove(text);
				_callbacks.ResourceRestoreCompleted?.Invoke(context, text, arg);
			}
			catch (Exception exception)
			{
				Reject(sender, "resource restore acknowledgement", exception);
			}
		}

		private static void OnMovePlayer(long sender, ZPackage package)
		{
			if (!TryBeginClientResponse(sender, package))
			{
				return;
			}
			try
			{
				PositionData arg = ReadPosition(package);
				float num = package.ReadSingle();
				if (!Finite(num))
				{
					throw new InvalidOperationException("Move rotation is invalid.");
				}
				RequireConsumed(package);
				Func<PositionData, float, bool> clientMoveRequested = _callbacks.ClientMoveRequested;
				if (clientMoveRequested == null || !clientMoveRequested(arg, num))
				{
					ManualLogSource log = Plugin.Log;
					if (log != null)
					{
						log.LogWarning((object)"The local player rejected an ArenaGuard move instruction.");
					}
				}
			}
			catch (Exception arg2)
			{
				ManualLogSource log2 = Plugin.Log;
				if (log2 != null)
				{
					log2.LogError((object)$"Could not apply ArenaGuard move instruction: {arg2}");
				}
			}
		}

		private static ArenaRpcResult TryAuthorizeGateTravel(ArenaRequestContext context, string gateId, bool returning, out ArenaGateTravelAuthorization authorization)
		{
			authorization = null;
			RemoveExpiredGateTravels();
			if (!ServerPortalRulesAllowTravel(out var rejection))
			{
				return ArenaRpcResult.Rejected(rejection);
			}
			ArenaDefinition definition;
			ArenaGateDefinition arenaGateDefinition;
			string arenaId;
			PositionData destination;
			float rotationY;
			if (returning)
			{
				if (!ArenaRegistry.TryGetRoute(context.PlayerId, out var route) || !ArenaRegistry.TryGetArena(route.ArenaId, out definition))
				{
					return ArenaRpcResult.Rejected("No saved arena entrance is available for your character.");
				}
				if (definition.Markers == null || !WithinDistance(context.Position, definition.Markers.HubGatePosition, 10f))
				{
					return ArenaRpcResult.Rejected("Stand next to the arena return gate to leave.");
				}
				arenaGateDefinition = ArenaRegistry.ResolveReturnGate(context.PlayerId);
				if (arenaGateDefinition == null)
				{
					return ArenaRpcResult.Rejected("Your entrance gate and the arena fallback gate are unavailable.");
				}
				arenaId = definition.ArenaId;
				gateId = arenaGateDefinition.GateId;
				destination = arenaGateDefinition.Position;
				rotationY = arenaGateDefinition.RotationY;
			}
			else
			{
				if (!ArenaRegistry.TryGetGate(gateId, out var definition2) || !ArenaRegistry.TryGetArena(definition2.ArenaId, out definition) || !definition.Enabled || definition.Markers == null)
				{
					return ArenaRpcResult.Rejected("That arena entrance is unavailable.");
				}
				if (!WithinDistance(context.Position, definition2.Position, 10f))
				{
					return ArenaRpcResult.Rejected("Stand next to the Arena Gate to use it.");
				}
				arenaGateDefinition = definition2;
				arenaId = definition.ArenaId;
				destination = definition.Markers.StagingPosition;
				rotationY = 0f;
			}
			ArenaRpcResult arenaRpcResult = ((_callbacks.GateTravelAuthorizing == null) ? ArenaRpcResult.Rejected("Arena gate routing is not ready.") : (_callbacks.GateTravelAuthorizing(context, arenaGateDefinition, returning) ?? ArenaRpcResult.Rejected("Arena server returned no gate result.")));
			if (!arenaRpcResult.Success)
			{
				return arenaRpcResult;
			}
			authorization = new ArenaGateTravelAuthorization
			{
				TravelToken = Guid.NewGuid().ToString("N").ToLowerInvariant(),
				GateId = gateId,
				ArenaId = arenaId,
				Destination = destination,
				RotationY = rotationY,
				Returning = returning
			};
			PendingGateTravels[authorization.TravelToken] = new PendingGateTravel
			{
				Context = context,
				Authorization = authorization,
				ExpiresUtc = DateTime.UtcNow.Add(GateTravelTimeout)
			};
			return ArenaRpcResult.Accepted();
		}

		private static bool ServerPortalRulesAllowTravel(out string rejection)
		{
			ZoneSystem instance = ZoneSystem.instance;
			if ((Object)(object)instance != (Object)null && instance.GetGlobalKey((GlobalKeys)27))
			{
				rejection = "Portals are disabled in this world.";
				return false;
			}
			if ((Object)(object)instance != (Object)null && instance.GetGlobalKey((GlobalKeys)28))
			{
				bool num = (Object)(object)RandEventSystem.instance != (Object)null && !string.IsNullOrEmpty(RandEventSystem.instance.GetBossEvent());
				float num2 = default(float);
				bool flag = instance.GetGlobalKey((GlobalKeys)38, ref num2) && num2 > 0f;
				if (num || flag)
				{
					rejection = "Portals are blocked while a boss is active.";
					return false;
				}
			}
			rejection = string.Empty;
			return true;
		}

		private static void CompleteLocalGateTravel(ArenaRequestContext context, ArenaGateTravelAuthorization authorization)
		{
			bool accepted = false;
			try
			{
				accepted = _callbacks.ClientGateTravelAuthorized?.Invoke(authorization) ?? false;
			}
			catch (Exception arg)
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogError((object)$"Could not apply local ArenaGuard gate destination: {arg}");
				}
			}
			PendingGateTravels.Remove(authorization.TravelToken);
			ReceiveLocalResult(CompleteGateTravel(context, authorization, accepted));
		}

		private static ArenaRpcResult CompleteGateTravel(ArenaRequestContext context, ArenaGateTravelAuthorization authorization, bool accepted)
		{
			ArenaRpcResult arenaRpcResult;
			if (_callbacks.GateTravelCompleted != null)
			{
				arenaRpcResult = _callbacks.GateTravelCompleted(context, authorization, accepted);
				if (arenaRpcResult == null)
				{
					return ArenaRpcResult.Rejected("Arena server returned no gate completion result.");
				}
			}
			else
			{
				arenaRpcResult = ArenaRpcResult.Rejected("Arena gate completion is not ready.");
			}
			return arenaRpcResult;
		}

		private static void RemoveExpiredGateTravels()
		{
			DateTime now = DateTime.UtcNow;
			foreach (string item in (from pair in PendingGateTravels
				where pair.Value.ExpiresUtc <= now
				select pair.Key).ToList())
			{
				PendingGateTravel pendingGateTravel = PendingGateTravels[item];
				PendingGateTravels.Remove(item);
				try
				{
					CompleteGateTravel(pendingGateTravel.Context, pendingGateTravel.Authorization, accepted: false);
				}
				catch (Exception ex)
				{
					ManualLogSource log = Plugin.Log;
					if (log != null)
					{
						log.LogWarning((object)("Could not expire gate travel '" + item + "': " + ex.Message));
					}
				}
			}
		}

		private static void RemoveExpiredResourceRestores()
		{
			DateTime now = DateTime.UtcNow;
			foreach (string item in (from pair in PendingResourceRestores
				where pair.Value.ExpiresUtc <= now
				select pair.Key).ToList())
			{
				PendingResourceRestore pendingResourceRestore = PendingResourceRestores[item];
				PendingResourceRestores.Remove(item);
				_callbacks.ResourceRestoreCompleted?.Invoke(pendingResourceRestore.Context, item, arg3: false);
			}
		}

		private static string ResourceRestoreKey(PlayerResourceSnapshot snapshot)
		{
			return snapshot.PlayerId + ":" + snapshot.CapturedUtc.ToBinary();
		}

		private static void RememberAppliedResourceRestore(string key)
		{
			if (AppliedResourceRestoreKeys.Add(key))
			{
				AppliedResourceRestoreOrder.Enqueue(key);
				while (AppliedResourceRestoreOrder.Count > 128)
				{
					AppliedResourceRestoreKeys.Remove(AppliedResourceRestoreOrder.Dequeue());
				}
			}
		}

		private static ArenaRpcResult Invoke(Func<ArenaRequestContext, ChallengeRequest, ArenaRpcResult> handler, ArenaRequestContext context, ChallengeRequest request)
		{
			ArenaRpcResult arenaRpcResult;
			if (handler != null)
			{
				arenaRpcResult = handler(context, request);
				if (arenaRpcResult == null)
				{
					return ArenaRpcResult.Rejected("Arena server returned no result.");
				}
			}
			else
			{
				arenaRpcResult = ArenaRpcResult.Rejected("Arena server is not ready.");
			}
			return arenaRpcResult;
		}

		private static ArenaRpcResult Invoke(Func<ArenaRequestContext, ArenaRpcResult> handler, ArenaRequestContext context)
		{
			ArenaRpcResult arenaRpcResult;
			if (handler != null)
			{
				arenaRpcResult = handler(context);
				if (arenaRpcResult == null)
				{
					return ArenaRpcResult.Rejected("Arena server returned no result.");
				}
			}
			else
			{
				arenaRpcResult = ArenaRpcResult.Rejected("Arena server is not ready.");
			}
			return arenaRpcResult;
		}

		private static ArenaRpcResult InvokeAdmin(ArenaRequestContext context, ArenaAdminMutation mutation)
		{
			if (!context.IsAdmin)
			{
				return ArenaRpcResult.Rejected("Only a server administrator may change an arena.");
			}
			ArenaRpcResult arenaRpcResult;
			if (_callbacks.AdminMutationRequested != null)
			{
				arenaRpcResult = _callbacks.AdminMutationRequested(context, mutation);
				if (arenaRpcResult == null)
				{
					return ArenaRpcResult.Rejected("Arena server returned no result.");
				}
			}
			else
			{
				arenaRpcResult = ArenaRpcResult.Rejected("Arena administration is not ready.");
			}
			return arenaRpcResult;
		}

		private static void ValidateAdminMutation(ArenaAdminMutation mutation)
		{
			if (mutation == null || mutation.Kind < ArenaAdminMutationKind.RegisterArena || mutation.Kind > ArenaAdminMutationKind.ClearArenaQueue)
			{
				throw new ArgumentException("Unknown administrator mutation type.", "mutation");
			}
			switch (mutation.Kind)
			{
			case ArenaAdminMutationKind.RegisterArena:
				if (mutation.Arena == null)
				{
					throw new ArgumentException("Arena definition is required.");
				}
				break;
			case ArenaAdminMutationKind.RemoveArena:
			case ArenaAdminMutationKind.RemoveGate:
				mutation.TargetId = RequireId(mutation.TargetId, "mutation target ID");
				break;
			case ArenaAdminMutationKind.SetMarkers:
				mutation.TargetId = RequireId(mutation.TargetId, "arena ID");
				if (mutation.Markers == null || mutation.Markers.EnemySpawnPositions == null || mutation.Markers.EnemySpawnPositions.Count != 4)
				{
					throw new ArgumentException("A complete marker set requires exactly four enemy positions.");
				}
				break;
			case ArenaAdminMutationKind.RegisterGate:
				if (mutation.Gate == null)
				{
					throw new ArgumentException("Gate definition is required.");
				}
				break;
			case ArenaAdminMutationKind.SetMarker:
			case ArenaAdminMutationKind.RemoveMarker:
			{
				mutation.TargetId = RequireId(mutation.TargetId, "arena ID");
				bool flag = mutation.MarkerKind == 2;
				if (mutation.MarkerKind < 0 || mutation.MarkerKind > 3 || (flag && (mutation.MarkerSlot < 0 || mutation.MarkerSlot > 3)) || (!flag && mutation.MarkerSlot != -1) || !Finite(mutation.MarkerPosition.X) || !Finite(mutation.MarkerPosition.Y) || !Finite(mutation.MarkerPosition.Z))
				{
					throw new ArgumentException("Incremental marker kind, slot, or position is invalid.");
				}
				break;
			}
			case ArenaAdminMutationKind.SetAdminTerrainPermission:
			case ArenaAdminMutationKind.SetAdminBuildingPermission:
			case ArenaAdminMutationKind.SetAdminPickupPermission:
				mutation.TargetId = RequireId(mutation.TargetId, "arena ID");
				break;
			case ArenaAdminMutationKind.RequestAdminStatus:
			case ArenaAdminMutationKind.AbortAllArenas:
				mutation.TargetId = Trim(mutation.TargetId, 64);
				break;
			case ArenaAdminMutationKind.AbortArena:
			case ArenaAdminMutationKind.ClearArenaQueue:
				mutation.TargetId = Trim(mutation.TargetId, 64);
				if (string.IsNullOrWhiteSpace(mutation.TargetId))
				{
					throw new ArgumentException("An arena ID or name is required.");
				}
				break;
			}
		}

		private static bool TryBeginServerRequest(long sender, ZPackage package, out ArenaRequestContext context)
		{
			context = null;
			ZNet instance = ZNet.instance;
			if ((Object)(object)instance == (Object)null || !instance.IsServer())
			{
				return false;
			}
			if (!ValidatePackageHeader(package, "client request"))
			{
				return false;
			}
			if (!TryResolvePeer(instance.GetPeer(sender), out context))
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogWarning((object)$"Rejected ArenaGuard request from unresolved peer {sender}.");
				}
				SendResult(sender, ArenaRpcResult.Rejected("Your player character is not ready."));
				return false;
			}
			return true;
		}

		private static bool TryBeginClientResponse(long sender, ZPackage package)
		{
			ZNet instance = ZNet.instance;
			if ((Object)(object)instance == (Object)null || instance.IsServer())
			{
				return false;
			}
			ZNetPeer serverPeer = instance.GetServerPeer();
			if (serverPeer == null || sender != serverPeer.m_uid)
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogWarning((object)$"Ignored ArenaGuard response from non-server peer {sender}.");
				}
				return false;
			}
			return ValidatePackageHeader(package, "server response");
		}

		private static bool ValidatePackageHeader(ZPackage package, string direction)
		{
			try
			{
				if (package == null || package.Size() <= 0 || package.Size() > 1048576)
				{
					throw new InvalidOperationException("Package size is invalid.");
				}
				int num = package.ReadInt();
				string text = ReadString(package, 32);
				if (num != 8 || !string.Equals(text, "0.0.3", StringComparison.Ordinal))
				{
					throw new InvalidOperationException($"Protocol/version mismatch ({num}, '{text}'). " + string.Format("Expected ({0}, '{1}').", 8, "0.0.3"));
				}
				return true;
			}
			catch (Exception ex)
			{
				ManualLogSource log = Plugin.Log;
				if (log != null)
				{
					log.LogWarning((object)("Rejected ArenaGuard " + direction + ": " + ex.Message));
				}
				return false;
			}
		}

		private static ZPackage NewPackage()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Expected O, but got Unknown
			ZPackage val = new ZPackage();
			val.Write(8);
			val.Write("0.0.3");
			return val;
		}

		private static bool TryPrepareLocalRequest(out ZNet znet, out ZRoutedRpc rpc)
		{
			znet = ZNet.instance;
			rpc = ZRoutedRpc.instance;
			if ((Object)(object)znet != (Object)null && rpc != null)
			{
				return true;
			}
			ReceiveLocalResult(ArenaRpcResult.Rejected("Arena networking is not ready."));
			return false;
		}

		private static bool TryResolveLocalContext(out ArenaRequestContext context)
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			context = null;
			Player localPlayer = Player.m_localPlayer;
			ZNet instance = ZNet.instance;
			if ((Object)(object)localPlayer == (Object)null || (Object)(object)instance == (Object)null || !instance.IsServer())
			{
				return false;
			}
			Vector3 position = ((Component)localPlayer).transform.position;
			context = new ArenaRequestContext
			{
				PeerUid = 0L,
				PlayerId = localPlayer.GetPlayerID(),
				PlayerName = (localPlayer.GetPlayerName() ?? string.Empty),
				IsAdmin = instance.LocalPlayerIsAdminOrHost(),
				Position = new PositionData
				{
					X = position.x,
					Y = position.y,
					Z = position.z
				}
			};
			return context.PlayerId > 0;
		}

		private static bool TryResolvePeer(ZNetPeer peer, out ArenaRequestContext context)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			//IL_012e: Unknown result type (might be due to invalid IL or missing references)
			//IL_013c: Unknown result type (might be due to invalid IL or missing references)
			context = null;
			if (peer == null || peer.m_characterID == ZDOID.None || ZDOMan.instance == null || (Object)(object)ZNetScene.instance == (Object)null)
			{
				return false;
			}
			ZDO zDO = ZDOMan.instance.GetZDO(peer.m_characterID);
			if (zDO == null || zDO.GetOwner() != peer.m_uid)
			{
				return false;
			}
			GameObject prefab = ZNetScene.instance.GetPrefab(zDO.GetPrefab());
			if ((Object)(object)prefab == (Object)null || (Object)(object)prefab.GetComponent<Player>() == (Object)null)
			{
				return false;
			}
			long num = zDO.GetLong(ZDOVars.s_playerID, 0L);
			if (num <= 0)
			{
				return false;
			}
			string text = zDO.GetString(ZDOVars.s_playerName, peer.m_playerName ?? string.Empty);
			Vector3 position = zDO.GetPosition();
			ZNet instance = ZNet.instance;
			bool isAdmin = (Object)(object)instance != (Object)null && peer.m_socket != null && instance.IsAdmin(peer.m_socket.GetHostName());
			context = new ArenaRequestContext
			{
				PeerUid = peer.m_uid,
				PlayerId = num,
				PlayerName = (text ?? string.Empty),
				IsAdmin = isAdmin,
				Position = new PositionData
				{
					X = position.x,
					Y = position.y,
					Z = position.z
				}
			};
			return true;
		}

		private static ChallengeRequest SanitizeClientChallenge(ChallengeRequest source)
		{
			if (source == null)
			{
				throw new ArgumentNullException("source");
			}
			string arenaId = RequireId(source.ArenaId, "arena ID");
			if (source.Mode < ChallengeMode.BiomeLadder || source.Mode > ChallengeMode.CustomEncounter)
			{
				throw new ArgumentOutOfRangeException("Mode");
			}
			if (source.CapMode < ProgressionCapMode.Gauntlet || source.CapMode > ProgressionCapMode.Biome)
			{
				throw new ArgumentOutOfRangeException("CapMode");
			}
			if (source.CapMode == ProgressionCapMode.Biome && (source.SelectedBiome < BiomeTier.Meadows || source.SelectedBiome > BiomeTier.DeepNorth))
			{
				throw new ArgumentOutOfRangeException("SelectedBiome");
			}
			CustomEncounterSelection customSelection = null;
			if (source.Mode == ChallengeMode.CustomEncounter)
			{
				if (source.CustomSelection == null || string.IsNullOrWhiteSpace(source.CustomSelection.CreatureKey) || source.CustomSelection.CreatureKey.Length > 128 || source.CustomSelection.Quantity < 1 || source.CustomSelection.Quantity > 10 || source.CustomSelection.Stars < StarLevel.Base || source.CustomSelection.Stars > StarLevel.TwoStar)
				{
					throw new ArgumentException("Custom encounter selection is invalid.", "source");
				}
				customSelection = new CustomEncounterSelection
				{
					CreatureKey = source.CustomSelection.CreatureKey.Trim(),
					Stars = source.CustomSelection.Stars,
					Quantity = source.CustomSelection.Quantity
				};
			}
			return new ChallengeRequest
			{
				ArenaId = arenaId,
				Mode = source.Mode,
				CapMode = ((source.Mode == ChallengeMode.CustomEncounter) ? ProgressionCapMode.Gauntlet : source.CapMode),
				SelectedBiome = ((source.CapMode != ProgressionCapMode.Biome) ? BiomeTier.BlackForest : source.SelectedBiome),
				CustomSelection = customSelection
			};
		}

		private static ChallengeRequest StampIdentity(ChallengeRequest request, ArenaRequestContext context)
		{
			request.RequestId = Guid.NewGuid().ToString("N").ToLowerInvariant();
			request.PlayerId = context.PlayerId;
			request.PlayerName = context.PlayerName;
			request.RequestedUtc = DateTime.UtcNow;
			return request;
		}

		private static bool ValidateChallengeLocation(ArenaRequestContext context, ChallengeRequest request, out string rejection)
		{
			if (!ArenaRegistry.TryGetArena(request.ArenaId, out var definition) || !definition.Enabled)
			{
				rejection = "The selected arena is unavailable.";
				return false;
			}
			float num = definition.CorePosition.X - context.Position.X;
			float num2 = definition.CorePosition.Z - context.Position.Z;
			if (num * num + num2 * num2 > definition.ProtectedRadius * definition.ProtectedRadius)
			{
				rejection = "Use the challenge sign from inside the selected arena.";
				return false;
			}
			rejection = string.Empty;
			return true;
		}

		private static void SendResult(long peerUid, ArenaRpcResult result)
		{
			result = result ?? ArenaRpcResult.Rejected("Arena server returned no result.");
			if (peerUid == 0L)
			{
				ReceiveLocalResult(result);
				return;
			}
			ZRoutedRpc instance = ZRoutedRpc.instance;
			if (instance != null)
			{
				ZPackage val = NewPackage();
				val.Write(result.Success);
				val.Write(Trim(result.Message, 256));
				instance.InvokeRoutedRPC(peerUid, "jg224.arenaguard.ActionResult", new object[1] { val });
			}
		}

		private static void ReceiveLocalResult(ArenaRpcResult result)
		{
			if (result != null)
			{
				_callbacks.ClientActionResultReceived?.Invoke(result.Success, result.Message ?? string.Empty);
			}
		}

		private static void Reject(long peerUid, string operation, Exception exception)
		{
			ManualLogSource log = Plugin.Log;
			if (log != null)
			{
				log.LogWarning((object)$"Rejected ArenaGuard {operation} from peer {peerUid}: {exception.Message}");
			}
			SendResult(peerUid, ArenaRpcResult.Rejected(exception.Message));
		}

		private static void WriteChallengeRequest(ZPackage package, ChallengeRequest request, bool includeIdentity)
		{
			package.Write(request.ArenaId ?? string.Empty);
			package.Write((int)request.Mode);
			package.Write((int)request.CapMode);
			package.Write((int)request.SelectedBiome);
			package.Write(request.CustomSelection != null);
			if (request.CustomSelection != null)
			{
				package.Write(request.CustomSelection.CreatureKey ?? string.Empty);
				package.Write((int)request.CustomSelection.Stars);
				package.Write(request.CustomSelection.Quantity);
			}
			if (includeIdentity)
			{
				package.Write(request.RequestId ?? string.Empty);
				package.Write(request.PlayerId);
				package.Write(request.PlayerName ?? string.Empty);
				package.Write(request.RequestedUtc.ToBinary());
			}
		}

		private static ChallengeRequest ReadChallengeRequest(ZPackage package, bool includeIdentity)
		{
			ChallengeRequest challengeRequest = new ChallengeRequest
			{
				ArenaId = ReadString(package, 64),
				Mode = (ChallengeMode)package.ReadInt(),
				CapMode = (ProgressionCapMode)package.ReadInt(),
				SelectedBiome = (BiomeTier)package.ReadInt()
			};
			if (package.ReadBool())
			{
				challengeRequest.CustomSelection = new CustomEncounterSelection
				{
					CreatureKey = ReadString(package, 128),
					Stars = (StarLevel)package.ReadInt(),
					Quantity = package.ReadInt()
				};
			}
			if (includeIdentity)
			{
				challengeRequest.RequestId = ReadString(package, 64);
				challengeRequest.PlayerId = package.ReadLong();
				challengeRequest.PlayerName = ReadString(package, 64);
				challengeRequest.RequestedUtc = DateTime.FromBinary(package.ReadLong());
			}
			return SanitizeClientChallenge(challengeRequest);
		}

		private static void WriteAdminMutation(ZPackage package, ArenaAdminMutation mutation)
		{
			package.Write((int)mutation.Kind);
			package.Write(mutation.TargetId ?? string.Empty);
			package.Write(mutation.Arena != null);
			if (mutation.Arena != null)
			{
				WriteArena(package, mutation.Arena);
			}
			package.Write(mutation.Markers != null);
			if (mutation.Markers != null)
			{
				WriteMarkers(package, mutation.Markers);
			}
			package.Write(mutation.Gate != null);
			if (mutation.Gate != null)
			{
				WriteGate(package, mutation.Gate);
			}
			if (mutation.Kind == ArenaAdminMutationKind.SetMarker || mutation.Kind == ArenaAdminMutationKind.RemoveMarker)
			{
				package.Write(mutation.MarkerKind);
				package.Write(mutation.MarkerSlot);
				WritePosition(package, mutation.MarkerPosition);
			}
			if (mutation.Kind == ArenaAdminMutationKind.SetAdminTerrainPermission || mutation.Kind == ArenaAdminMutationKind.SetAdminBuildingPermission || mutation.Kind == ArenaAdminMutationKind.SetAdminPickupPermission)
			{
				package.Write(mutation.Enabled);
			}
		}

		private static void WriteGateTravelAuthorization(ZPackage package, ArenaGateTravelAuthorization authorization)
		{
			package.Write(authorization.TravelToken ?? string.Empty);
			package.Write(authorization.GateId ?? string.Empty);
			package.Write(authorization.ArenaId ?? string.Empty);
			WritePosition(package, authorization.Destination);
			package.Write(authorization.RotationY);
			package.Write(authorization.Returning);
		}

		private static ArenaGateTravelAuthorization ReadGateTravelAuthorization(ZPackage package)
		{
			ArenaGateTravelAuthorization obj = new ArenaGateTravelAuthorization
			{
				TravelToken = RequireId(ReadString(package, 64), "travel token"),
				GateId = RequireId(ReadString(package, 64), "gate ID"),
				ArenaId = RequireId(ReadString(package, 64), "arena ID"),
				Destination = ReadPosition(package),
				RotationY = package.ReadSingle(),
				Returning = package.ReadBool()
			};
			if (!Finite(obj.RotationY))
			{
				throw new InvalidOperationException("Gate destination rotation is invalid.");
			}
			return obj;
		}

		private static ArenaAdminMutation ReadAdminMutation(ZPackage package)
		{
			ArenaAdminMutation arenaAdminMutation = new ArenaAdminMutation
			{
				Kind = (ArenaAdminMutationKind)package.ReadInt(),
				TargetId = ReadString(package, 64)
			};
			if (arenaAdminMutation.Kind < ArenaAdminMutationKind.RegisterArena || arenaAdminMutation.Kind > ArenaAdminMutationKind.ClearArenaQueue)
			{
				throw new InvalidOperationException("Unknown administrator mutation type.");
			}
			if (package.ReadBool())
			{
				arenaAdminMutation.Arena = ReadArena(package);
			}
			if (package.ReadBool())
			{
				arenaAdminMutation.Markers = ReadMarkers(package);
			}
			if (package.ReadBool())
			{
				arenaAdminMutation.Gate = ReadGate(package);
			}
			if (arenaAdminMutation.Kind == ArenaAdminMutationKind.SetMarker || arenaAdminMutation.Kind == ArenaAdminMutationKind.RemoveMarker)
			{
				arenaAdminMutation.MarkerKind = package.ReadInt();
				arenaAdminMutation.MarkerSlot = package.ReadInt();
				arenaAdminMutation.MarkerPosition = ReadPosition(package);
				if (arenaAdminMutation.MarkerKind < 0 || arenaAdminMutation.MarkerKind > 3 || arenaAdminMutation.MarkerSlot < -1 || arenaAdminMutation.MarkerSlot > 3 || string.IsNullOrWhiteSpace(arenaAdminMutation.TargetId))
				{
					throw new InvalidOperationException("Incremental arena marker mutation is invalid.");
				}
				arenaAdminMutation.TargetId = RequireId(arenaAdminMutation.TargetId, "arena ID");
			}
			if (arenaAdminMutation.Kind == ArenaAdminMutationKind.SetAdminTerrainPermission || arenaAdminMutation.Kind == ArenaAdminMutationKind.SetAdminBuildingPermission || arenaAdminMutation.Kind == ArenaAdminMutationKind.SetAdminPickupPermission)
			{
				arenaAdminMutation.Enabled = package.ReadBool();
				arenaAdminMutation.TargetId = RequireId(arenaAdminMutation.TargetId, "arena ID");
			}
			return arenaAdminMutation;
		}

		private static void WriteArena(ZPackage package, ArenaDefinition arena)
		{
			package.Write(arena.ArenaId ?? string.Empty);
			package.Write(arena.DisplayName ?? string.Empty);
			WritePosition(package, arena.CorePosition);
			package.Write(arena.CombatRadius);
			package.Write(arena.ProtectedRadius);
			package.Write(arena.Enabled);
			package.Write(arena.Revision);
			package.Write(arena.Markers != null);
			if (arena.Markers != null)
			{
				WriteMarkers(package, arena.Markers);
			}
		}

		private static ArenaDefinition ReadArena(ZPackage package)
		{
			ArenaDefinition arenaDefinition = new ArenaDefinition
			{
				ArenaId = ReadString(package, 64),
				DisplayName = ReadString(package, 64),
				CorePosition = ReadPosition(package),
				CombatRadius = package.ReadSingle(),
				ProtectedRadius = package.ReadSingle(),
				Enabled = package.ReadBool(),
				Revision = package.ReadLong()
			};
			if (package.ReadBool())
			{
				arenaDefinition.Markers = ReadMarkers(package);
			}
			return arenaDefinition;
		}

		private static void WriteMarkers(ZPackage package, ArenaMarkerSet markers)
		{
			WritePosition(package, markers.StagingPosition);
			WritePosition(package, markers.CombatantStartPosition);
			WritePosition(package, markers.HubGatePosition);
			int num = markers.EnemySpawnPositions?.Count ?? 0;
			package.Write(num);
			for (int i = 0; i < num; i++)
			{
				WritePosition(package, markers.EnemySpawnPositions[i]);
			}
		}

		private static ArenaMarkerSet ReadMarkers(ZPackage package)
		{
			ArenaMarkerSet arenaMarkerSet = new ArenaMarkerSet
			{
				StagingPosition = ReadPosition(package),
				CombatantStartPosition = ReadPosition(package),
				HubGatePosition = ReadPosition(package),
				EnemySpawnPositions = new List<PositionData>()
			};
			int num = package.ReadInt();
			if (num < 0 || num > 4)
			{
				throw new InvalidOperationException("Enemy marker count is invalid.");
			}
			for (int i = 0; i < num; i++)
			{
				arenaMarkerSet.EnemySpawnPositions.Add(ReadPosition(package));
			}
			return arenaMarkerSet;
		}

		private static void WriteGate(ZPackage package, ArenaGateDefinition gate)
		{
			package.Write(gate.GateId ?? string.Empty);
			package.Write(gate.ArenaId ?? string.Empty);
			package.Write(gate.DisplayName ?? string.Empty);
			WritePosition(package, gate.Position);
			package.Write(gate.RotationY);
			package.Write(gate.IsFallbackEntrance);
		}

		private static ArenaGateDefinition ReadGate(ZPackage package)
		{
			return ValidateAndCopyGate(new ArenaGateDefinition
			{
				GateId = ReadString(package, 64),
				ArenaId = ReadString(package, 64),
				DisplayName = ReadString(package, 64),
				Position = ReadPosition(package),
				RotationY = package.ReadSingle(),
				IsFallbackEntrance = package.ReadBool()
			});
		}

		private static ArenaGateDefinition ValidateAndCopyGate(ArenaGateDefinition source)
		{
			if (source == null)
			{
				throw new ArgumentNullException("source");
			}
			string text = (source.DisplayName ?? string.Empty).Trim();
			if (text.Length == 0 || text.Length > 64 || !Finite(source.RotationY) || !Finite(source.Position.X) || !Finite(source.Position.Y) || !Finite(source.Position.Z))
			{
				throw new ArgumentException("Gate configuration is invalid.", "source");
			}
			return new ArenaGateDefinition
			{
				GateId = RequireId(source.GateId, "gate ID"),
				ArenaId = RequireId(source.ArenaId, "arena ID"),
				DisplayName = text,
				Position = source.Position,
				RotationY = source.RotationY,
				IsFallbackEntrance = source.IsFallbackEntrance
			};
		}

		private static void WriteArenaSnapshot(ZPackage package, ArenaClientSnapshot snapshot)
		{
			package.Write(snapshot.ArenaId ?? string.Empty);
			package.Write(snapshot.SessionId ?? string.Empty);
			package.Write(snapshot.ArenaName ?? string.Empty);
			WritePosition(package, snapshot.CorePosition);
			package.Write(snapshot.CombatRadius);
			package.Write(snapshot.ProtectedRadius);
			package.Write(snapshot.Markers != null);
			if (snapshot.Markers != null)
			{
				WriteMarkers(package, snapshot.Markers);
			}
			package.Write((int)snapshot.Phase);
			package.Write(snapshot.CombatantPlayerId);
			package.Write(snapshot.CombatantName ?? string.Empty);
			package.Write(snapshot.QueuePosition);
			package.Write(snapshot.QueueLength);
			package.Write(snapshot.EncounterIndex);
			package.Write(snapshot.EncounterCount);
			package.Write(snapshot.CurrentEncounter != null);
			if (snapshot.CurrentEncounter != null)
			{
				WriteEncounter(package, snapshot.CurrentEncounter);
			}
			package.Write(snapshot.CountdownSeconds);
			package.Write(snapshot.ElapsedMilliseconds);
			package.Write(snapshot.PreparationComplete);
			package.Write(snapshot.AdminsMayModifyTerrain);
			package.Write(snapshot.AdminsMayBuild);
			package.Write(snapshot.AdminsMayPickupDroppedItems);
		}

		private static ArenaClientSnapshot ReadArenaSnapshot(ZPackage package)
		{
			ArenaClientSnapshot arenaClientSnapshot = new ArenaClientSnapshot
			{
				ArenaId = RequireId(ReadString(package, 64), "arena ID"),
				SessionId = ReadString(package, 64),
				ArenaName = ReadString(package, 64),
				CorePosition = ReadPosition(package),
				CombatRadius = package.ReadSingle(),
				ProtectedRadius = package.ReadSingle()
			};
			if (!Finite(arenaClientSnapshot.CombatRadius) || !Finite(arenaClientSnapshot.ProtectedRadius) || arenaClientSnapshot.CombatRadius <= 0f || arenaClientSnapshot.ProtectedRadius <= arenaClientSnapshot.CombatRadius)
			{
				throw new InvalidOperationException("Arena snapshot bounds are invalid.");
			}
			if (package.ReadBool())
			{
				arenaClientSnapshot.Markers = ReadMarkers(package);
			}
			arenaClientSnapshot.Phase = (SessionPhase)package.ReadInt();
			arenaClientSnapshot.CombatantPlayerId = package.ReadLong();
			arenaClientSnapshot.CombatantName = ReadString(package, 64);
			arenaClientSnapshot.QueuePosition = package.ReadInt();
			arenaClientSnapshot.QueueLength = package.ReadInt();
			arenaClientSnapshot.EncounterIndex = package.ReadInt();
			arenaClientSnapshot.EncounterCount = package.ReadInt();
			if (arenaClientSnapshot.Phase < SessionPhase.Queued || arenaClientSnapshot.Phase > SessionPhase.Closed || arenaClientSnapshot.QueuePosition < 0 || arenaClientSnapshot.QueueLength < 0 || arenaClientSnapshot.EncounterIndex < 0 || arenaClientSnapshot.EncounterCount < 0)
			{
				throw new InvalidOperationException("Arena snapshot values are invalid.");
			}
			if (!string.IsNullOrWhiteSpace(arenaClientSnapshot.SessionId))
			{
				arenaClientSnapshot.SessionId = RequireId(arenaClientSnapshot.SessionId, "session ID");
			}
			if (arenaClientSnapshot.Phase != SessionPhase.Closed && string.IsNullOrWhiteSpace(arenaClientSnapshot.SessionId))
			{
				throw new InvalidOperationException("An active arena snapshot requires a session ID.");
			}
			if (package.ReadBool())
			{
				arenaClientSnapshot.CurrentEncounter = ReadEncounter(package);
			}
			arenaClientSnapshot.CountdownSeconds = package.ReadInt();
			arenaClientSnapshot.ElapsedMilliseconds = package.ReadLong();
			arenaClientSnapshot.PreparationComplete = package.ReadBool();
			arenaClientSnapshot.AdminsMayModifyTerrain = package.ReadBool();
			arenaClientSnapshot.AdminsMayBuild = package.ReadBool();
			arenaClientSnapshot.AdminsMayPickupDroppedItems = package.ReadBool();
			if (arenaClientSnapshot.CountdownSeconds < 0 || arenaClientSnapshot.ElapsedMilliseconds < 0)
			{
				throw new InvalidOperationException("Arena snapshot timing is invalid.");
			}
			return arenaClientSnapshot;
		}

		private static void WriteEncounter(ZPackage package, EncounterDefinition encounter)
		{
			package.Write(encounter.Sequence);
			package.Write(encounter.CreatureKey ?? string.Empty);
			package.Write((int)encounter.Biome);
			package.Write((int)encounter.Stars);
			package.Write(encounter.Quantity);
			package.Write(encounter.IsMiniboss);
			package.Write(encounter.PreparationSeconds);
		}

		private static EncounterDefinition ReadEncounter(ZPackage package)
		{
			EncounterDefinition encounterDefinition = new EncounterDefinition
			{
				Sequence = package.ReadInt(),
				CreatureKey = ReadString(package, 128),
				Biome = (BiomeTier)package.ReadInt(),
				Stars = (StarLevel)package.ReadInt(),
				Quantity = package.ReadInt(),
				IsMiniboss = package.ReadBool(),
				PreparationSeconds = package.ReadInt()
			};
			if (encounterDefinition.Sequence < 0 || string.IsNullOrWhiteSpace(encounterDefinition.CreatureKey) || encounterDefinition.Biome < BiomeTier.Meadows || encounterDefinition.Biome > BiomeTier.DeepNorth || encounterDefinition.Stars < StarLevel.Base || encounterDefinition.Stars > StarLevel.TwoStar || encounterDefinition.Quantity < 1 || encounterDefinition.Quantity > 10 || encounterDefinition.PreparationSeconds < 0 || encounterDefinition.PreparationSeconds > 300)
			{
				throw new InvalidOperationException("Encounter definition is invalid.");
			}
			return encounterDefinition;
		}

		private static void WriteLeaderboardKey(ZPackage package, LeaderboardKey key)
		{
			package.Write((int)key.Mode);
			package.Write((int)key.CapMode);
			package.Write((int)key.SelectedBiome);
			package.Write(key.CustomCreatureKey ?? string.Empty);
			package.Write((int)key.CustomStars);
			package.Write(key.CustomQuantity);
		}

		private static LeaderboardKey ReadLeaderboardKey(ZPackage package)
		{
			return NormalizeLeaderboardKey(new LeaderboardKey
			{
				Mode = (ChallengeMode)package.ReadInt(),
				CapMode = (ProgressionCapMode)package.ReadInt(),
				SelectedBiome = (BiomeTier)package.ReadInt(),
				CustomCreatureKey = ReadString(package, 128),
				CustomStars = (StarLevel)package.ReadInt(),
				CustomQuantity = package.ReadInt()
			});
		}

		private static LeaderboardKey NormalizeLeaderboardKey(LeaderboardKey key)
		{
			if (key == null || key.Mode < ChallengeMode.BiomeLadder || key.Mode > ChallengeMode.CustomEncounter || key.CapMode < ProgressionCapMode.Gauntlet || key.CapMode > ProgressionCapMode.Biome)
			{
				throw new ArgumentException("Leaderboard key is invalid.", "key");
			}
			if (key.Mode != ChallengeMode.CustomEncounter)
			{
				if (key.CapMode == ProgressionCapMode.Biome && (key.SelectedBiome < BiomeTier.Meadows || key.SelectedBiome > BiomeTier.DeepNorth))
				{
					throw new ArgumentException("Leaderboard biome is invalid.", "key");
				}
				return new LeaderboardKey
				{
					Mode = key.Mode,
					CapMode = key.CapMode,
					SelectedBiome = ((key.CapMode != ProgressionCapMode.Biome) ? BiomeTier.BlackForest : key.SelectedBiome),
					CustomCreatureKey = string.Empty
				};
			}
			if (string.IsNullOrWhiteSpace(key.CustomCreatureKey) || key.CustomCreatureKey.Length > 128 || key.CustomStars < StarLevel.Base || key.CustomStars > StarLevel.TwoStar || key.CustomQuantity < 1 || key.CustomQuantity > 10)
			{
				throw new ArgumentException("Custom leaderboard key is invalid.", "key");
			}
			return new LeaderboardKey
			{
				Mode = key.Mode,
				CapMode = ProgressionCapMode.Gauntlet,
				SelectedBiome = BiomeTier.BlackForest,
				CustomCreatureKey = key.CustomCreatureKey.Trim().ToLowerInvariant(),
				CustomStars = key.CustomStars,
				CustomQuantity = key.CustomQuantity
			};
		}

		private static void WriteLeaderboardEntry(ZPackage package, LeaderboardEntry entry)
		{
			package.Write(entry.PlayerId);
			package.Write(entry.PlayerName ?? string.Empty);
			package.Write(entry.Completed);
			package.Write(entry.FurthestEncounterIndex);
			package.Write(entry.ElapsedMilliseconds);
			package.Write(entry.RosterRevision);
			package.Write(entry.RecordedUtc.ToBinary());
		}

		private static LeaderboardEntry ReadLeaderboardEntry(ZPackage package, LeaderboardKey key)
		{
			LeaderboardEntry leaderboardEntry = new LeaderboardEntry
			{
				Key = key,
				PlayerId = package.ReadLong(),
				PlayerName = ReadString(package, 64),
				Completed = package.ReadBool(),
				FurthestEncounterIndex = package.ReadInt(),
				ElapsedMilliseconds = package.ReadLong(),
				RosterRevision = package.ReadLong(),
				RecordedUtc = DateTime.FromBinary(package.ReadLong())
			};
			if (leaderboardEntry.PlayerId <= 0 || string.IsNullOrWhiteSpace(leaderboardEntry.PlayerName) || leaderboardEntry.FurthestEncounterIndex < 0 || leaderboardEntry.ElapsedMilliseconds < 0 || leaderboardEntry.RosterRevision < 0)
			{
				throw new InvalidOperationException("Leaderboard entry is invalid.");
			}
			return leaderboardEntry;
		}

		private static void WriteResourceSnapshot(ZPackage package, PlayerResourceSnapshot snapshot, bool includeIdentity)
		{
			if (includeIdentity)
			{
				package.Write(snapshot.PlayerId);
				package.Write(snapshot.CapturedUtc.ToBinary());
			}
			package.Write(snapshot.Foods.Count);
			foreach (FoodStateSnapshot food in snapshot.Foods)
			{
				package.Write(food.ItemPrefabName ?? string.Empty);
				package.Write(food.RemainingSeconds);
				package.Write(food.Health);
				package.Write(food.Stamina);
				package.Write(food.Eitr);
			}
			package.Write(snapshot.RestedRemainingSeconds);
			package.Write(snapshot.ArenaFoodPrefabNames.Count);
			foreach (string arenaFoodPrefabName in snapshot.ArenaFoodPrefabNames)
			{
				package.Write(arenaFoodPrefabName ?? string.Empty);
			}
			WriteIntDictionary(package, snapshot.AllowedConsumableCounts);
			WriteIntDictionary(package, snapshot.AmmunitionCounts);
			package.Write(snapshot.EquipmentDurabilityBySlot.Count);
			foreach (KeyValuePair<string, float> item in snapshot.EquipmentDurabilityBySlot.OrderBy<KeyValuePair<string, float>, string>((KeyValuePair<string, float> pair) => pair.Key, StringComparer.Ordinal))
			{
				package.Write(item.Key);
				package.Write(item.Value);
			}
		}

		private static PlayerResourceSnapshot ReadResourceSnapshot(ZPackage package, bool includeIdentity)
		{
			PlayerResourceSnapshot playerResourceSnapshot = new PlayerResourceSnapshot
			{
				PlayerId = (includeIdentity ? package.ReadLong() : 0),
				CapturedUtc = (includeIdentity ? DateTime.FromBinary(package.ReadLong()) : DateTime.UtcNow),
				Foods = new List<FoodStateSnapshot>(),
				ArenaFoodPrefabNames = new List<string>(),
				AllowedConsumableCounts = new Dictionary<string, int>(StringComparer.Ordinal),
				AmmunitionCounts = new Dictionary<string, int>(StringComparer.Ordinal),
				EquipmentDurabilityBySlot = new Dictionary<string, float>(StringComparer.Ordinal)
			};
			int num = ReadCount(package, 3, "food");
			for (int i = 0; i < num; i++)
			{
				FoodStateSnapshot foodStateSnapshot = new FoodStateSnapshot
				{
					ItemPrefabName = ReadString(package, 128),
					RemainingSeconds = package.ReadSingle(),
					Health = package.ReadSingle(),
					Stamina = package.ReadSingle(),
					Eitr = package.ReadSingle()
				};
				if (string.IsNullOrWhiteSpace(foodStateSnapshot.ItemPrefabName) || !FiniteNonNegative(foodStateSnapshot.RemainingSeconds) || !FiniteNonNegative(foodStateSnapshot.Health) || !FiniteNonNegative(foodStateSnapshot.Stamina) || !FiniteNonNegative(foodStateSnapshot.Eitr))
				{
					throw new InvalidOperationException("Food snapshot entry is invalid.");
				}
				playerResourceSnapshot.Foods.Add(foodStateSnapshot);
			}
			playerResourceSnapshot.RestedRemainingSeconds = package.ReadSingle();
			if (!FiniteNonNegative(playerResourceSnapshot.RestedRemainingSeconds))
			{
				throw new InvalidOperationException("Rested snapshot duration is invalid.");
			}
			int num2 = ReadCount(package, 3, "arena food");
			for (int j = 0; j < num2; j++)
			{
				string text = ReadString(package, 128).Trim();
				if (text.Length == 0 || playerResourceSnapshot.ArenaFoodPrefabNames.Contains(text))
				{
					throw new InvalidOperationException("Arena food snapshot entry is invalid or duplicated.");
				}
				playerResourceSnapshot.ArenaFoodPrefabNames.Add(text);
			}
			ReadIntDictionary(package, playerResourceSnapshot.AllowedConsumableCounts);
			ReadIntDictionary(package, playerResourceSnapshot.AmmunitionCounts);
			int num3 = ReadCount(package, 1024, "equipment durability");
			for (int k = 0; k < num3; k++)
			{
				string text2 = ReadString(package, 128);
				float value = package.ReadSingle();
				if (string.IsNullOrWhiteSpace(text2) || !FiniteNonNegative(value) || playerResourceSnapshot.EquipmentDurabilityBySlot.ContainsKey(text2))
				{
					throw new InvalidOperationException("Equipment durability entry is invalid or duplicated.");
				}
				playerResourceSnapshot.EquipmentDurabilityBySlot.Add(text2, value);
			}
			return ValidateAndCopyResourceSnapshot(playerResourceSnapshot, playerResourceSnapshot.PlayerId, includeIdentity);
		}

		private static PlayerResourceSnapshot ValidateAndCopyResourceSnapshot(PlayerResourceSnapshot source, long expectedPlayerId, bool requireIdentity)
		{
			if (source == null)
			{
				throw new ArgumentNullException("source");
			}
			if (requireIdentity && (expectedPlayerId <= 0 || source.PlayerId != expectedPlayerId))
			{
				throw new ArgumentException("Resource snapshot targets another character.", "source");
			}
			if ((source.Foods?.Count ?? 0) > 3 || (source.ArenaFoodPrefabNames?.Count ?? 0) > 3 || (source.AllowedConsumableCounts?.Count ?? 0) > 1024 || (source.AmmunitionCounts?.Count ?? 0) > 1024 || (source.EquipmentDurabilityBySlot?.Count ?? 0) > 1024)
			{
				throw new ArgumentException("Resource snapshot collection limit exceeded.", "source");
			}
			PlayerResourceSnapshot playerResourceSnapshot = new PlayerResourceSnapshot
			{
				PlayerId = (requireIdentity ? expectedPlayerId : 0),
				CapturedUtc = (requireIdentity ? source.CapturedUtc : DateTime.UtcNow),
				Foods = new List<FoodStateSnapshot>(),
				RestedRemainingSeconds = source.RestedRemainingSeconds,
				ArenaFoodPrefabNames = new List<string>(),
				AllowedConsumableCounts = CopyIntDictionary(source.AllowedConsumableCounts, "consumable"),
				AmmunitionCounts = CopyIntDictionary(source.AmmunitionCounts, "ammunition"),
				EquipmentDurabilityBySlot = new Dictionary<string, float>(StringComparer.Ordinal)
			};
			foreach (FoodStateSnapshot item in source.Foods ?? new List<FoodStateSnapshot>())
			{
				if (item == null || string.IsNullOrWhiteSpace(item.ItemPrefabName) || item.ItemPrefabName.Length > 128 || !FiniteNonNegative(item.RemainingSeconds) || !FiniteNonNegative(item.Health) || !FiniteNonNegative(item.Stamina) || !FiniteNonNegative(item.Eitr))
				{
					throw new ArgumentException("Food snapshot entry is invalid.", "source");
				}
				playerResourceSnapshot.Foods.Add(new FoodStateSnapshot
				{
					ItemPrefabName = item.ItemPrefabName.Trim(),
					RemainingSeconds = item.RemainingSeconds,
					Health = item.Health,
					Stamina = item.Stamina,
					Eitr = item.Eitr
				});
			}
			if (!FiniteNonNegative(source.RestedRemainingSeconds))
			{
				throw new ArgumentException("Rested snapshot duration is invalid.", "source");
			}
			foreach (string item2 in source.ArenaFoodPrefabNames ?? new List<string>())
			{
				string text = (item2 ?? string.Empty).Trim();
				if (text.Length == 0 || text.Length > 128 || playerResourceSnapshot.ArenaFoodPrefabNames.Contains(text))
				{
					throw new ArgumentException("Arena food snapshot entry is invalid or duplicated.", "source");
				}
				playerResourceSnapshot.ArenaFoodPrefabNames.Add(text);
			}
			foreach (KeyValuePair<string, float> item3 in source.EquipmentDurabilityBySlot ?? new Dictionary<string, float>())
			{
				string text2 = (item3.Key ?? string.Empty).Trim();
				if (text2.Length == 0 || text2.Length > 128 || !FiniteNonNegative(item3.Value) || playerResourceSnapshot.EquipmentDurabilityBySlot.ContainsKey(text2))
				{
					throw new ArgumentException("Equipment durability entry is invalid.", "source");
				}
				playerResourceSnapshot.EquipmentDurabilityBySlot.Add(text2, item3.Value);
			}
			return playerResourceSnapshot;
		}

		private static Dictionary<string, int> CopyIntDictionary(Dictionary<string, int> source, string label)
		{
			Dictionary<string, int> dictionary = new Dictionary<string, int>(StringComparer.Ordinal);
			foreach (KeyValuePair<string, int> item in source ?? new Dictionary<string, int>())
			{
				string text = (item.Key ?? string.Empty).Trim();
				if (text.Length == 0 || text.Length > 128 || item.Value < 0 || dictionary.ContainsKey(text))
				{
					throw new ArgumentException(label + " snapshot entry is invalid.");
				}
				dictionary.Add(text, item.Value);
			}
			return dictionary;
		}

		private static void WriteIntDictionary(ZPackage package, Dictionary<string, int> values)
		{
			package.Write(values.Count);
			foreach (KeyValuePair<string, int> item in values.OrderBy<KeyValuePair<string, int>, string>((KeyValuePair<string, int> pair) => pair.Key, StringComparer.Ordinal))
			{
				package.Write(item.Key);
				package.Write(item.Value);
			}
		}

		private static void ReadIntDictionary(ZPackage package, Dictionary<string, int> destination)
		{
			int num = ReadCount(package, 1024, "resource");
			for (int i = 0; i < num; i++)
			{
				string text = ReadString(package, 128);
				int num2 = package.ReadInt();
				if (string.IsNullOrWhiteSpace(text) || num2 < 0 || destination.ContainsKey(text))
				{
					throw new InvalidOperationException("Resource entry is invalid or duplicated.");
				}
				destination.Add(text, num2);
			}
		}

		private static int ReadCount(ZPackage package, int maximum, string label)
		{
			int num = package.ReadInt();
			if (num < 0 || num > maximum)
			{
				throw new InvalidOperationException(label + " count is invalid.");
			}
			return num;
		}

		private static void WritePosition(ZPackage package, PositionData position)
		{
			package.Write(position.X);
			package.Write(position.Y);
			package.Write(position.Z);
		}

		private static PositionData ReadPosition(ZPackage package)
		{
			PositionData result = new PositionData
			{
				X = package.ReadSingle(),
				Y = package.ReadSingle(),
				Z = package.ReadSingle()
			};
			if (!Finite(result.X) || !Finite(result.Y) || !Finite(result.Z))
			{
				throw new InvalidOperationException("Position contains a non-finite value.");
			}
			return result;
		}

		private static string ReadString(ZPackage package, int maximumLength)
		{
			string obj = package.ReadString() ?? string.Empty;
			if (obj.Length > maximumLength)
			{
				throw new InvalidOperationException("String exceeds protocol limit.");
			}
			return obj;
		}

		private static string Trim(string value, int maximumLength)
		{
			value = value ?? string.Empty;
			if (value.Length > maximumLength)
			{
				return value.Substring(0, maximumLength);
			}
			return value;
		}

		private static string RequireId(string value, string label)
		{
			return ArenaRegistry.NormalizeId(value) ?? throw new ArgumentException("Invalid " + label + ".");
		}

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

		private static bool FiniteNonNegative(float value)
		{
			if (Finite(value))
			{
				return value >= 0f;
			}
			return false;
		}

		private static bool WithinDistance(PositionData first, PositionData second, float maximum)
		{
			float num = first.X - second.X;
			float num2 = first.Y - second.Y;
			float num3 = first.Z - second.Z;
			return num * num + num2 * num2 + num3 * num3 <= maximum * maximum;
		}

		private static void RequireConsumed(ZPackage package)
		{
			if (package.GetPos() != package.Size())
			{
				throw new InvalidOperationException("Package contains unexpected trailing data.");
			}
		}

		private static void DetachPeerHook()
		{
			if (_registeredInstance != null && _newPeerHandler != null)
			{
				ZRoutedRpc registeredInstance = _registeredInstance;
				registeredInstance.m_onNewPeer = (Action<long>)Delegate.Remove(registeredInstance.m_onNewPeer, _newPeerHandler);
			}
			_newPeerHandler = null;
		}
	}
}
namespace ArenaGuard.Domain
{
	public enum BiomeTier
	{
		Meadows,
		BlackForest,
		Swamp,
		Mountain,
		Plains,
		Mistlands,
		Ashlands,
		DeepNorth
	}
	public enum ChallengeMode
	{
		BiomeLadder = 1,
		StarLadder,
		CustomEncounter
	}
	public enum ProgressionCapMode
	{
		Gauntlet = 1,
		Biome
	}
	public enum StarLevel
	{
		Base,
		OneStar,
		TwoStar
	}
	public enum SessionPhase
	{
		Queued,
		Called,
		Staging,
		Countdown,
		Fighting,
		Intermission,
		Victory,
		Defeat,
		Forfeit,
		Recovering,
		Closed
	}
	public enum SessionOutcome
	{
		None,
		Victory,
		Defeat,
		Forfeit,
		StartTimeout,
		BoundaryForfeit,
		Disconnect,
		ServerRestart,
		ArenaRemoved,
		RuntimeError
	}
	public enum ArenaRole
	{
		Visitor,
		Queued,
		Combatant,
		Spectator,
		Administrator
	}
	public enum ArenaMarkerKind
	{
		Staging,
		CombatantStart,
		EnemySpawn,
		HubGate
	}
	public enum ArenaEffectType
	{
		CallQueuedPlayer,
		MoveToStaging,
		StartCountdown,
		SpawnEncounter,
		DespawnSessionEnemies,
		RestorePlayerState,
		MoveToSpectatorArea,
		SetArenaRole,
		PersistState,
		UpdateLeaderboard,
		SendLocalMessage,
		SendGlobalMessage
	}
	public struct PositionData
	{
		public float X;

		public float Y;

		public float Z;
	}
	public sealed class ArenaMarkerSet
	{
		public PositionData StagingPosition;

		public PositionData CombatantStartPosition;

		public PositionData HubGatePosition;

		public List<PositionData> EnemySpawnPositions;
	}
	public sealed class ArenaDefinition
	{
		public string ArenaId;

		public string DisplayName;

		public string NormalizedName;

		public PositionData CorePosition;

		public float CombatRadius;

		public float ProtectedRadius;

		public ArenaMarkerSet Markers;

		public bool Enabled;

		public long Revision;
	}
	public sealed class ArenaGateDefinition
	{
		public string GateId;

		public string ArenaId;

		public string DisplayName;

		public string NormalizedName;

		public PositionData Position;

		public float RotationY;

		public bool IsFallbackEntrance;
	}
	public sealed class PlayerArenaRoute
	{
		public long PlayerId;

		public string ArenaId;

		public string OriginGateId;

		public DateTime EnteredUtc;
	}
	public sealed class CreatureDefinition
	{
		public string CreatureKey;

		public string PrefabName;

		public string SecondaryPrefabName;

		public string IconPrefabName;

		public string SecondaryIconPrefabName;

		public string DisplayName;

		public BiomeTier Biome;

		public int DifficultyOrder;

		public bool IsMiniboss;

		public bool Enabled;

		public List<StarLevel> SupportedStars;
	}
	public sealed class CustomEncounterSelection
	{
		public string CreatureKey;

		public StarLevel Stars;

		public int Quantity;
	}
	public sealed class ChallengeRequest
	{
		public string RequestId;

		public string ArenaId;

		public long PlayerId;

		public string PlayerName;

		public ChallengeMode Mode;

		public ProgressionCapMode CapMode;

		public BiomeTier SelectedBiome;

		public CustomEncounterSelection CustomSelection;

		public DateTime RequestedUtc;
	}
	public sealed class EncounterDefinition
	{
		public int Sequence;

		public string CreatureKey;

		public BiomeTier Biome;

		public StarLevel Stars;

		public int Quantity;

		public bool IsMiniboss;

		public int PreparationSeconds;
	}
	public sealed class ChallengePlan
	{
		public string PlanId;

		public ChallengeMode Mode;

		public ProgressionCapMode CapMode;

		public BiomeTier HighestBiome;

		public long RosterRevision;

		public List<EncounterDefinition> Encounters;
	}
	public sealed class QueueEntry
	{
		public ChallengeRequest Request;

		public string OriginGateId;

		public int QueueSequence;

		public DateTime EnqueuedUtc;
	}
	public sealed class FoodStateSnapshot
	{
		public string ItemPrefabName;

		public float RemainingSeconds;

		public float Health;

		public float Stamina;

		public float Eitr;
	}
	public sealed class ArenaFoodDefinition
	{
		public string PrefabName;

		public string DisplayName;

		public float Health;

		public float Stamina;

		public float Eitr;

		public float DurationSeconds;
	}
	public sealed class PlayerResourceSnapshot
	{
		public long PlayerId;

		public List<FoodStateSnapshot> Foods;

		public float RestedRemainingSeconds;

		public List<string> ArenaFoodPrefabNames;

		public Dictionary<string, int> AllowedConsumableCounts;

		public Dictionary<string, int> AmmunitionCounts;

		public Dictionary<string, float> EquipmentDurabilityBySlot;

		public DateTime CapturedUtc;
	}
	public sealed class ArenaSession
	{
		public string SessionId;

		public string ArenaId;

		public ChallengeRequest Request;

		public ChallengePlan Plan;

		public SessionPhase Phase;

		public SessionOutcome Outcome;

		public int EncounterIndex;

		public int LivingArenaEnemyCount;

		public List<string> SpawnedEnemyIds;

		public PlayerResourceSnapshot ResourceSnapshot;

		public DateTime PhaseStartedUtc;

		public DateTime PhaseDeadlineUtc;

		public DateTime SessionStartedUtc;

		public long ElapsedMilliseconds;
	}
	public sealed class ArenaEffect
	{
		public ArenaEffectType Type;

		public string ArenaId;

		public string SessionId;

		public long PlayerId;

		public EncounterDefinition Encounter;

		public string Message;
	}
	public sealed class LeaderboardKey
	{
		public ChallengeMode Mode;

		public ProgressionCapMode CapMode;

		public BiomeTier SelectedBiome;

		public string CustomCreatureKey;

		public StarLevel CustomStars;

		public int CustomQuantity;
	}
	public sealed class LeaderboardEntry
	{
		public LeaderboardKey Key;

		public long PlayerId;

		public string PlayerName;

		public bool Completed;

		public int FurthestEncounterIndex;

		public long ElapsedMilliseconds;

		public long RosterRevision;

		public DateTime RecordedUtc;
	}
	public sealed class ArenaClientSnapshot
	{
		public string ArenaId;

		public string SessionId;

		public string ArenaName;

		public PositionData CorePosition;

		public float CombatRadius;

		public float ProtectedRadius;

		public ArenaMarkerSet Markers;

		public SessionPhase Phase;

		public long CombatantPlayerId;

		public string CombatantName;

		public int QueuePosition;

		public int QueueLength;

		public int EncounterIndex;

		public int EncounterCount;

		public EncounterDefinition CurrentEncounter;

		public int CountdownSeconds;

		public long ElapsedMilliseconds;

		public bool PreparationComplete;

		public bool AdminsMayModifyTerrain;

		public bool AdminsMayBuild;

		public bool AdminsMayPickupDroppedItems;
	}
	public sealed class PersistedWorldState
	{
		public long WorldUid;

		public long RosterRevision;

		public List<ArenaDefinition> Arenas;

		public List<ArenaGateDefinition> Gates;

		public List<PlayerArenaRoute> Routes;

		public List<QueueEntry> Queue;

		public List<ArenaSession> InterruptedSessions;

		public List<LeaderboardEntry> Leaderboard;
	}
}
namespace ArenaGuard.Config
{
	internal static class ArenaConfig
	{
		private static ConfigFile _config;

		internal static ConfigEntry<float> DefaultCombatRadius { get; private set; }

		internal static ConfigEntry<float> DefaultProtectedRadius { get; private set; }

		internal static ConfigEntry<int> QueueAcceptSeconds { get; private set; }

		internal static ConfigEntry<int> StagingTimeoutSeconds { get; private set; }

		internal static ConfigEntry<int> EncounterCountdownSeconds { get; private set; }

		internal static ConfigEntry<int> BoundaryGraceSeconds { get; private set; }

		internal static ConfigEntry<int> ResultsSeconds { get; private set; }

		internal static ConfigEntry<bool> ShowAdminSetupVisuals { get; private set; }

		internal static ConfigEntry<KeyboardShortcut> ToggleAdminSetupVisualsShortcut { get; private set; }

		internal static ConfigEntry<bool> AllowAdminTerrainEditing { get; private set; }

		internal static ConfigEntry<bool> AllowAdminBuilding { get; private set; }

		internal static ConfigEntry<bool> AllowAdminDroppedItemPickup { get; private set; }

		internal static ConfigEntry<bool> VerboseLogging { get; private set; }

		internal static void Bind(ConfigFile config)
		{
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			_config = config;
			DefaultCombatRadius = config.Bind<float>("Arena", "DefaultCombatRadius", 20f, "Default horizontal combat-floor radius, in metres.");
			DefaultProtectedRadius = config.Bind<float>("Arena", "DefaultProtectedRadius", 30f, "Default horizontal structure-protection radius, in metres.");
			QueueAcceptSeconds = config.Bind<int>("Timing", "QueueAcceptSeconds", 30, "Seconds the next queued player has to accept their turn.");
			StagingTimeoutSeconds = config.Bind<int>("Timing", "StagingTimeoutSeconds", 60, "Seconds an accepted player has to enter the combat floor.");
			EncounterCountdownSeconds = config.Bind<int>("Timing", "EncounterCountdownSeconds", 3, "Countdown before each encounter spawns.");
			BoundaryGraceSeconds = config.Bind<int>("Timing", "BoundaryGraceSeconds", 5, "Seconds a combatant may remain outside the combat floor before forfeiting.");
			ResultsSeconds = config.Bind<int>("Timing", "ResultsSeconds", 5, "Seconds to show results before returning the player to staging.");
			ShowAdminSetupVisuals = config.Bind<bool>("Admin", "ShowSetupVisuals", true, "Show Arena Cores, radius rings, Combat Start, and Enemy Spawn beacons to this admin client. Non-admins never see them.");
			ToggleAdminSetupVisualsShortcut = config.Bind<KeyboardShortcut>("Admin", "ToggleSetupVisualsShortcut", new KeyboardShortcut((KeyCode)288, Array.Empty<KeyCode>()), "Local shortcut used by an authenticated admin to show or hide SkaldHall setup visuals.");
			AllowAdminTerrainEditing = config.Bind<bool>("Admin", "AllowTerrainEditing", true, "Server-wide: allow authenticated non-combatant admins with devcommands enabled to modify terrain inside protected arenas.");
			AllowAdminBuilding = config.Bind<bool>("Admin", "AllowBuilding", true, "Server-wide: allow authenticated non-combatant admins to build and demolish inside protected arenas.");
			AllowAdminDroppedItemPickup = config.Bind<bool>("Admin", "AllowDroppedItemPickup", true, "Server-wide: allow authenticated non-combatant admins to manually or automatically pick up dropped items inside arenas.");
			VerboseLogging = config.Bind<bool>("Diagnostics", "VerboseLogging", false, "Write additional SkaldHall diagnostic messages.");
		}

		internal static void Save()
		{
			ConfigFile config = _config;
			if (config != null)
			{
				config.Save();
			}
		}
	}
}
namespace ArenaGuard.Challenges
{
	public sealed class ChallengeCatalog
	{
		public const int DefaultPreparationSeconds = 3;

		public const int MinimumCustomQuantity = 1;

		public const int MaximumCustomQuantity = 10;

		private readonly List<CreatureDefinition> _roster;

		public long RosterRevision { get; }

		public ChallengeCatalog()
			: this(LoadRoster(), 3L)
		{
		}

		public ChallengeCatalog(IEnumerable<CreatureDefinition> roster, long rosterRevision)
		{
			if (roster == null)
			{
				throw new ArgumentNullException("roster");
			}
			if (rosterRevision < 1)
			{
				throw new ArgumentOutOfRangeException("rosterRevision", "Roster revision must be positive.");
			}
			_roster = roster.Select(CloneCreature).ToList();
			ValidateRoster(_roster);
			RosterRevision = rosterRevision;
		}

		public static IList<CreatureDefinition> LoadRoster()
		{
			return new List<CreatureDefinition>
			{
				Creature("greydwarf", "Greydwarf", "Greydwarf", BiomeTier.BlackForest, 10, isMiniboss: false, "TrophyGreydwarf"),
				Creature("greydwarf_shaman", "Greydwarf_Shaman", "Greydwarf Shaman", BiomeTier.BlackForest, 20, isMiniboss: false, "TrophyGreydwarfShaman"),
				Creature("skeleton", "Skeleton", "Skeleton", BiomeTier.BlackForest, 30, isMiniboss: false, "TrophySkeleton"),
				Creature("rancid_remains", "Skeleton_Poison", "Rancid Remains", BiomeTier.BlackForest, 40, isMiniboss: false, "TrophySkeletonPoison"),
				Creature("ghost", "Ghost", "Ghost", BiomeTier.BlackForest, 50, isMiniboss: false, "TrophyGhost"),
				Creature("greydwarf_brute", "Greydwarf_Elite", "Greydwarf Brute", BiomeTier.BlackForest, 60, isMiniboss: false, "TrophyGreydwarfBrute"),
				Creature("troll", "Troll", "Troll", BiomeTier.BlackForest, 70, isMiniboss: false, "TrophyFrostTroll"),
				Creature("bear", "Bjorn", "Bear", BiomeTier.BlackForest, 80, isMiniboss: false, "TrophyBjorn"),
				Creature("brenna", "Skeleton_Hildir", "Brenna", BiomeTier.BlackForest, 90, isMiniboss: true, "TrophySkeletonHildir"),
				Creature("leech", "Leech", "Leech", BiomeTier.Swamp, 10, isMiniboss: false, "TrophyLeech"),
				Creature("blob", "Blob", "Blob", BiomeTier.Swamp, 20, isMiniboss: false, "TrophyBlob"),
				Creature("draugr", "Draugr", "Draugr", BiomeTier.Swamp, 30, isMiniboss: false, "TrophyDraugr"),
				Creature("draugr_archer", "Draugr_Ranged", "Draugr Archer", BiomeTier.Swamp, 40, isMiniboss: false, "TrophyDraugr"),
				Creature("surtling", "Surtling", "Surtling", BiomeTier.Swamp, 50, isMiniboss: false, "TrophySurtling"),
				Creature("wraith", "Wraith", "Wraith", BiomeTier.Swamp, 60, isMiniboss: false, "TrophyWraith"),
				Creature("draugr_elite", "Draugr_Elite", "Draugr Elite", BiomeTier.Swamp, 70, isMiniboss: false, "TrophyDraugrElite"),
				Creature("oozer", "BlobElite", "Oozer", BiomeTier.Swamp, 80, isMiniboss: false, "TrophyBlob"),
				Creature("abomination", "Abomination", "Abomination", BiomeTier.Swamp, 90, isMiniboss: false, "TrophyAbomination"),
				Creature("wolf", "Wolf", "Wolf", BiomeTier.Mountain, 10, isMiniboss: false, "TrophyWolf"),
				Creature("drake", "Hatchling", "Drake", BiomeTier.Mountain, 20, isMiniboss: false, "TrophyHatchling"),
				Creature("bat", "Bat", "Bat", BiomeTier.Mountain, 30, isMiniboss: false, "TrophyUlv"),
				Creature("ulv", "Ulv", "Ulv", BiomeTier.Mountain, 40, isMiniboss: false, "TrophyUlv"),
				Creature("cultist", "Fenring_Cultist", "Cultist", BiomeTier.Mountain, 50, isMiniboss: false, "TrophyCultist"),
				Creature("fenring", "Fenring", "Fenring", BiomeTier.Mountain, 60, isMiniboss: false, "TrophyFenring"),
				Creature("stone_golem", "StoneGolem", "Stone Golem", BiomeTier.Mountain, 70, isMiniboss: false, "TrophySGolem"),
				Creature("geirrhafa", "Fenring_Cultist_Hildir", "Geirrhafa", BiomeTier.Mountain, 80, isMiniboss: true, "TrophyCultist_Hildir"),
				Creature("deathsquito", "Deathsquito", "Deathsquito", BiomeTier.Plains, 10, isMiniboss: false, "TrophyDeathsquito"),
				Creature("fuling", "Goblin", "Fuling", BiomeTier.Plains, 20, isMiniboss: false, "TrophyGoblin"),
				Creature("fuling_archer", "GoblinArcher", "Fuling Archer", BiomeTier.Plains, 30, isMiniboss: false, "TrophyGoblin"),
				Creature("growth", "BlobTar", "Growth", BiomeTier.Plains, 40, isMiniboss: false, "TrophyGrowth"),
				Creature("fuling_shaman", "GoblinShaman", "Fuling Shaman", BiomeTier.Plains, 50, isMiniboss: false, "TrophyGoblinShaman"),
				Creature("fuling_berserker", "GoblinBrute", "Fuling Berserker", BiomeTier.Plains, 60, isMiniboss: false, "TrophyGoblinBrute"),
				Creature("cursed_bear", "Unbjorn", "Cursed Bear", BiomeTier.Plains, 70, isMiniboss: false, "TrophyBjornUndead"),
				Creature("zil_and_thungr", "GoblinShaman_Hildir_nochest", "Zil & Thungr", BiomeTier.Plains, 80, isMiniboss: true, "TrophyGoblinBruteBrosShaman", "GoblinBrute_Hildir", "TrophyGoblinBruteBrosBrute"),
				Creature("tick", "Tick", "Tick", BiomeTier.Mistlands, 10, isMiniboss: false, "TrophyTick"),
				Creature("seeker_brood", "SeekerBrood", "Seeker Brood", BiomeTier.Mistlands, 20, isMiniboss: false, "TrophySeeker"),
				Creature("seeker", "Seeker", "Seeker", BiomeTier.Mistlands, 30, isMiniboss: false, "TrophySeeker"),
				Creature("dvergr", "Dverger", "Dvergr Rogue", BiomeTier.Mistlands, 40, isMiniboss: false, "TrophyDvergr"),
				Creature("dvergr_fire_mage", "DvergerMageFire", "Dvergr Fire Mage", BiomeTier.Mistlands, 50, isMiniboss: false, "TrophyDvergr"),
				Creature("dvergr_ice_mage", "DvergerMageIce", "Dvergr Ice Mage", BiomeTier.Mistlands, 60, isMiniboss: false, "TrophyDvergr"),
				Creature("dvergr_support_mage", "DvergerMageSupport", "Dvergr Support Mage", BiomeTier.Mistlands, 70, isMiniboss: false, "TrophyDvergr"),
				Creature("gjall", "Gjall", "Gjall", BiomeTier.Mistlands, 80, isMiniboss: false, "TrophyGjall"),
				Creature("seeker_soldier", "SeekerBrute", "Seeker Soldier", BiomeTier.Mistlands, 90, isMiniboss: false, "TrophySeekerBrute"),
				Creature("charred_twitcher", "Charred_Twitcher", "Charred Twitcher", BiomeTier.Ashlands, 10, isMiniboss: false, "TrophyCharredMelee"),
				Creature("charred_archer", "Charred_Archer", "Charred Marksman", BiomeTier.Ashlands, 20, isMiniboss: false, "TrophyCharredArcher"),
				Creature("charred_warrior", "Charred_Melee", "Charred Warrior", BiomeTier.Ashlands, 30, isMiniboss: false, "TrophyCharredMelee"),
				Creature("charred_warlock", "Charred_Mage", "Charred Warlock", BiomeTier.Ashlands, 40, isMiniboss: false, "TrophyCharredMage"),
				Creature("volture", "Volture", "Volture", BiomeTier.Ashlands, 50, isMiniboss: false, "TrophyVolture"),
				Creature("lavablob", "BlobLava", "Lava Blob", BiomeTier.Ashlands, 60, isMiniboss: false, "TrophyBlob"),
				Creature("asksvin", "Asksvin", "Asksvin", BiomeTier.Ashlands, 70, isMiniboss: false, "TrophyAsksvin"),
				Creature("ashlands_dvergr", "DvergerAshlands", "Ashlands Dvergr", BiomeTier.Ashlands, 80, isMiniboss: false, "TrophyDvergr"),
				Creature("morgen", "Morgen", "Morgen", BiomeTier.Ashlands, 90, isMiniboss: false, "TrophyMorgen"),
				Creature("fallen_valkyrie", "FallenValkyrie", "Fallen Valkyrie", BiomeTier.Ashlands, 100, isMiniboss: false, "TrophyFallenValkyrie"),
				Creature("lord_reto", "Charred_Melee_Dyrnwyn", "Lord Reto", BiomeTier.Ashlands, 110, isMiniboss: true, "TrophyCharredMelee")
			};
		}

		public IList<CreatureDefinition> ListCreatures(BiomeTier biome)
		{
			return (from creature in OrderedEnabledRoster()
				where creature.Biome == biome
				select creature).Select(CloneCreature).ToList();
		}

		public IList<CreatureDefinition> GetRoster()
		{
			return _roster.Select(CloneCreature).ToList();
		}

		public ChallengePlan BuildPlan(ChallengeRequest request, BiomeTier highestUnlockedBiome)
		{
			ValidateRequest(request);
			ValidateBiome(highestUnlockedBiome, "highestUnlockedBiome");
			List<CreatureDefinition> list = OrderedEnabledRoster().ToList();
			if (list.Count == 0)
			{
				throw new InvalidOperationException("The enabled arena roster is empty.");
			}
			BiomeTier biomeTier = list.Max((CreatureDefinition creature) => creature.Biome);
			IEnumerable<CreatureDefinition> source;
			if (request.CapMode != ProgressionCapMode.Biome)
			{
				IEnumerable<CreatureDefinition> enumerable = list;
				source = enumerable;
			}
			else
			{
				source = list.Where((CreatureDefinition creature) => creature.Biome == request.SelectedBiome);
			}
			List<CreatureDefinition> list2 = source.ToList();
			BiomeTier highestBiome = ((request.CapMode == ProgressionCapMode.Biome) ? request.SelectedBiome : biomeTier);
			List<EncounterDefinition> list3 = new List<EncounterDefinition>();
			switch (request.Mode)
			{
			case ChallengeMode.BiomeLadder:
				foreach (CreatureDefinition item in list2)
				{
					RequireSupportedStar(item, StarLevel.Base, "Biome ladder");
					list3.Add(CreateEncounter(list3.Count, item, StarLevel.Base, 1));
				}
				break;
			case ChallengeMode.StarLadder:
				foreach (CreatureDefinition item2 in list2)
				{
					StarLevel[] array = new StarLevel[3]
					{
						StarLevel.Base,
						StarLevel.OneStar,
						StarLevel.TwoStar
					};
					foreach (StarLevel starLevel in array)
					{
						RequireSupportedStar(item2, starLevel, "Star ladder");
						list3.Add(CreateEncounter(list3.Count, item2, starLevel, 1));
					}
				}
				break;
			case ChallengeMode.CustomEncounter:
			{
				if (!TryValidateCustomSelection(request.CustomSelection, out var error))
				{
					throw new ArgumentException(error, "request");
				}
				CreatureDefinition creatureDefinition = list.Single((CreatureDefinition creature) => string.Equals(creature.CreatureKey, request.CustomSelection.CreatureKey.Trim(), StringComparison.OrdinalIgnoreCase));
				list3.Add(CreateEncounter(0, creatureDefinition, request.CustomSelection.Stars, request.CustomSelection.Quantity));
				highestBiome = creatureDefinition.Biome;
				break;
			}
			default:
				throw new ArgumentOutOfRangeException("request", "Unknown challenge mode.");
			}
			if (list3.Count == 0)
			{
				throw new InvalidOperationException((request.CapMode == ProgressionCapMode.Biome) ? "The selected biome contains no enabled arena encounters." : "The selected challenge scope contains no enabled encounters.");
			}
			return new ChallengePlan
			{
				PlanId = NewId(),
				Mode = request.Mode,
				CapMode = request.CapMode,
				HighestBiome = highestBiome,
				RosterRevision = RosterRevision,
				Encounters = list3
			};
		}

		public bool ValidateCustomSelection(CustomEncounterSelection selection)
		{
			string error;
			return TryValidateCustomSelection(selection, out error);
		}

		public bool TryValidateCustomSelection(CustomEncounterSelection selection, out string error)
		{
			if (selection == null)
			{
				error = "A custom encounter selection is required.";
				return false;
			}
			if (string.IsNullOrWhiteSpace(selection.CreatureKey))
			{
				error = "A creature must be selected.";
				return false;
			}
			if (selection.Quantity < 1 || selection.Quantity > 10)
			{
				error = "Custom encounter quantity must be between 1 and 10.";
				return false;
			}
			if (!Enum.IsDefined(typeof(StarLevel), selection.Stars))
			{
				error = "The selected star level is invalid.";
				return false;
			}
			CreatureDefinition creatureDefinition = _roster.FirstOrDefault((CreatureDefinition candidate) => candidate.Enabled && string.Equals(candidate.CreatureKey, selection.CreatureKey.Trim(), StringComparison.OrdinalIgnoreCase));
			if (creatureDefinition == null)
			{
				error = "The selected creature is not in the enabled arena roster.";
				return false;
			}
			if (!creatureDefinition.SupportedStars.Contains(selection.Stars))
			{
				error = "The selected creature does not support that star level.";
				return false;
			}
			error = string.Empty;
			return true;
		}

		private IEnumerable<CreatureDefinition> OrderedEnabledRoster()
		{
			return (from creature in _roster
				where creature.Enabled
				orderby creature.Biome, creature.IsMiniboss ? 1 : 0, creature.DifficultyOrder
				select creature).ThenBy<CreatureDefinition, string>((CreatureDefinition creature) => creature.CreatureKey, StringComparer.OrdinalIgnoreCase);
		}

		private static void ValidateRequest(ChallengeRequest request)
		{
			if (request == null)
			{
				throw new ArgumentNullException("request");
			}
			if (string.IsNullOrWhiteSpace(request.RequestId))
			{
				throw new ArgumentException("Request ID is required.", "request");
			}
			if (string.IsNullOrWhiteSpace(request.ArenaId))
			{
				throw new ArgumentException("Arena ID is required.", "request");
			}
			if (request.PlayerId == 0L)
			{
				throw new ArgumentException("Player ID is required.", "request");
			}
			if (!Enum.IsDefined(typeof(ChallengeMode), request.Mode))
			{
				throw new ArgumentException("Challenge mode is invalid.", "request");
			}
			if (!Enum.IsDefined(typeof(ProgressionCapMode), request.CapMode))
			{
				throw new ArgumentException("Challenge scope is invalid.", "request");
			}
			if (request.CapMode == ProgressionCapMode.Biome && !Enum.IsDefined(typeof(BiomeTier), request.SelectedBiome))
			{
				throw new ArgumentException("Selected biome is invalid.", "request");
			}
		}

		private static void ValidateRoster(IList<CreatureDefinition> roster)
		{
			HashSet<string> hashSet = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
			foreach (CreatureDefinition item in roster)
			{
				if (item == null)
				{
					throw new ArgumentException("The creature roster cannot contain null entries.", "roster");
				}
				if (string.IsNullOrWhiteSpace(item.CreatureKey) || string.IsNullOrWhiteSpace(item.PrefabName) || string.IsNullOrWhiteSpace(item.DisplayName))
				{
					throw new ArgumentException("Every roster entry requires a key, prefab name, and display name.", "roster");
				}
				item.CreatureKey = item.CreatureKey.Trim();
				item.PrefabName = item.PrefabName.Trim();
				item.DisplayName = item.DisplayName.Trim();
				ValidateBiome(item.Biome, "roster");
				if (!hashSet.Add(item.CreatureKey))
				{
					throw new ArgumentException("Creature keys must be unique (case-insensitive).", "roster");
				}
				if (item.DifficultyOrder < 0)
				{
					throw new ArgumentException("Creature difficulty order cannot be negative.", "roster");
				}
				if (item.SupportedStars == null || item.SupportedStars.Count == 0 || item.SupportedStars.Distinct().Count() != item.SupportedStars.Count || item.SupportedStars.Any((StarLevel star) => !Enum.IsDefined(typeof(StarLevel), star)))
				{
					throw new ArgumentException("Each creature needs a unique, valid supported-star list.", "roster");
				}
			}
		}

		private static void ValidateBiome(BiomeTier biome, string parameterName)
		{
			if (!Enum.IsDefined(typeof(BiomeTier), biome))
			{
				throw new ArgumentOutOfRangeException(parameterName, "Biome is invalid.");
			}
		}

		private static void RequireSupportedStar(CreatureDefinition creature, StarLevel star, string modeName)
		{
			if (!creature.SupportedStars.Contains(star))
			{
				throw new InvalidOperationException(modeName + " cannot include '" + creature.CreatureKey + "' because it does not support " + star.ToString() + ".");
			}
		}

		private static EncounterDefinition CreateEncounter(int sequence, CreatureDefinition creature, StarLevel stars, int quantity)
		{
			return new EncounterDefinition
			{
				Sequence = sequence,
				CreatureKey = creature.CreatureKey,
				Biome = creature.Biome,
				Stars = stars,
				Quantity = quantity,
				IsMiniboss = creature.IsMiniboss,
				PreparationSeconds = 3
			};
		}

		private static CreatureDefinition Creature(string key, string prefab, string displayName, BiomeTier biome, int difficulty, bool isMiniboss = false, string iconPrefab = null, string secondaryPrefab = null, string secondaryIconPrefab = null)
		{
			return new CreatureDefinition
			{
				CreatureKey = key,
				PrefabName = prefab,
				SecondaryPrefabName = secondaryPrefab,
				IconPrefabName = iconPrefab,
				SecondaryIconPrefabName = secondaryIconPrefab,
				DisplayName = displayName,
				Biome = biome,
				DifficultyOrder = difficulty,
				IsMiniboss = isMiniboss,
				Enabled = true,
				SupportedStars = new List<StarLevel>
				{
					StarLevel.Base,
					StarLevel.OneStar,
					StarLevel.TwoStar
				}
			};
		}

		private static CreatureDefinition CloneCreature(CreatureDefinition creature)
		{
			if (creature == null)
			{
				return null;
			}
			return new CreatureDefinition
			{
				CreatureKey = creature.CreatureKey,
				PrefabName = creature.PrefabName,
				SecondaryPrefabName = creature.SecondaryPrefabName,
				IconPrefabName = creature.IconPrefabName,
				SecondaryIconPrefabName = creature.SecondaryIconPrefabName,
				DisplayName = creature.DisplayName,
				Biome = creature.Biome,
				DifficultyOrder = creature.DifficultyOrder,
				IsMiniboss = creature.IsMiniboss,
				Enabled = creature.Enabled,
				SupportedStars = ((creature.SupportedStars == null) ? null : new List<StarLevel>(creature.SupportedStars))
			};
		}

		private static string NewId()
		{
			return Guid.NewGuid().ToString("N").ToLowerInvariant();
		}
	}
}
namespace ArenaGuard.Arenas
{
	internal static class ArenaRegistry
	{
		private static readonly object Sync = new object();

		private static readonly Dictionary<string, ArenaDefinition> Arenas = new Dictionary<string, ArenaDefinition>(StringComparer.Ordinal);

		private static readonly Dictionary<string, string> ArenaNames = new Dictionary<string, string>(StringComparer.Ordinal);

		private static readonly Dictionary<string, ArenaGateDefinition> Gates = new Dictionary<string, ArenaGateDefinition>(StringComparer.Ordinal);

		private static readonly Dictionary<string, string> GateNames = new Dictionary<string, string>(StringComparer.Ordinal);

		private static readonly Dictionary<long, PlayerArenaRoute> Routes = new Dictionary<long, PlayerArenaRoute>();

		private static readonly Dictionary<string, List<QueueEntry>> Queues = new Dictionary<string, List<QueueEntry>>(StringComparer.Ordinal);

		private static readonly Dictionary<string, ArenaSession> ActiveSessions = new Dictionary<string, ArenaSession>(StringComparer.Ordinal);

		private const float UnsetMarkerCoordinate = float.MaxValue;

		internal static bool RegisterArena(ArenaDefinition definition)
		{
			ArenaDefinition arenaDefinition = NormalizeAndCopyArena(definition, validateEnabled: true);
			lock (Sync)
			{
				if (ArenaNames.TryGetValue(arenaDefinition.NormalizedName, out var value) && !string.Equals(value, arenaDefinition.ArenaId, StringComparison.Ordinal))
				{
					return false;
				}
				if (Arenas.TryGetValue(arenaDefinition.ArenaId, out var value2))
				{
					ArenaNames.Remove(value2.NormalizedName);
					arenaDefinition.Revision = Math.Max(value2.Revision + 1, arenaDefinition.Revision);
				}
				else
				{
					arenaDefinition.Revision = Math.Max(1L, arenaDefinition.Revision);
				}
				Arenas[arenaDefinition.ArenaId] = arenaDefinition;
				ArenaNames[arenaDefinition.NormalizedName] = arenaDefinition.ArenaId;
				if (!Queues.ContainsKey(arenaDefinition.ArenaId))
				{
					Queues[arenaDefinition.ArenaId] = new List<QueueEntry>();
				}
				return true;
			}
		}

		internal static bool RemoveArena(string arenaId)
		{
			arenaId = NormalizeId(arenaId);
			if (arenaId == null)
			{
				return false;
			}
			lock (Sync)
			{
				if (!Arenas.TryGetValue(arenaId, out var value))
				{
					return false;
				}
				Arenas.Remove(arenaId);
				ArenaNames.Remove(value.NormalizedName);
				foreach (string item in (from gate in Gates.Values
					where string.Equals(gate.ArenaId, arenaId, StringComparison.Ordinal)
					select gate.GateId).ToList())
				{
					GateNames.Remove(Gates[item].NormalizedName);
					Gates.Remove(item);
				}
				foreach (long item2 in (from route in Routes.Values
					where string.Equals(route.ArenaId, arenaId, StringComparison.Ordinal)
					select route.PlayerId).ToList())
				{
					Routes.Remove(item2);
				}
				Queues.Remove(arenaId);
				ActiveSessions.Remove(arenaId);
				return true;
			}
		}

		internal static bool TryGetArena(string arenaId, out ArenaDefinition definition)
		{
			arenaId = NormalizeId(arenaId);
			lock (Sync)
			{
				if (arenaId != null && Arenas.TryGetValue(arenaId, out var value))
				{
					definition = CopyArena(value);
					return true;
				}
			}
			definition = null;
			return false;
		}

		internal static bool TryGetArenaByName(string displayName, out ArenaDefinition definition)
		{
			string text = NormalizeName(displayName);
			lock (Sync)
			{
				if (text != null && ArenaNames.TryGetValue(text, out var value) && Arenas.TryGetValue(value, out var value2))
				{
					definition = CopyArena(value2);
					return true;
				}
			}
			definition = null;
			return false;
		}

		internal static ArenaDefinition FindProtectedArena(PositionData position)
		{
			lock (Sync)
			{
				ArenaDefinition arenaDefinition = FindContainingArena(position, combat: false);
				return (arenaDefinition == null) ? null : CopyArena(arenaDefinition);
			}
		}

		internal static ArenaDefinition FindCombatArena(PositionData position)
		{
			lock (Sync)
			{
				ArenaDefinition arenaDefinition = FindContainingArena(position, combat: true);
				return (arenaDefinition == null) ? null : CopyArena(arenaDefinition);
			}
		}

		internal static bool SetMarkers(string arenaId, ArenaMarkerSet markers)
		{
			arenaId = NormalizeId(arenaId);
			if (arenaId == null || !MarkersAreComplete(markers))
			{
				return false;
			}
			lock (Sync)
			{
				if (!Arenas.TryGetValue(arenaId, out var value))
				{
					return false;
				}
				if (!IsWithinCombatRadius(value, markers.CombatantStartPosition))
				{
					return false;
				}
				value.Markers = CopyMarkers(markers);
				value.Revision = Math.Max(1L, value.Revision + 1);
				return true;
			}
		}

		internal static bool SetMarker(string arenaId, ArenaMarkerKind kind, int slot, PositionData position)
		{
			arenaId = NormalizeId(arenaId);
			if (arenaId == null || !IsFinite(position) || IsUnsetMarker(position) || !MarkerSlotIsValid(kind, slot))
			{
				return false;
			}
			lock (Sync)
			{
				if (!Arenas.TryGetValue(arenaId, out var value))
				{
					return false;
				}
				if (kind == ArenaMarkerKind.CombatantStart && !IsWithinCombatRadius(value, position))
				{
					return false;
				}
				ArenaMarkerSet arenaMarkerSet = CopyOrCreatePartialMarkers(value.Markers);
				PositionData first;
				switch (kind)
				{
				case ArenaMarkerKind.Staging:
					first = arenaMarkerSet.StagingPosition;
					arenaMarkerSet.StagingPosition = position;
					break;
				case ArenaMarkerKind.CombatantStart:
					first = arenaMarkerSet.CombatantStartPosition;
					arenaMarkerSet.CombatantStartPosition = position;
					break;
				case ArenaMarkerKind.HubGate:
					first = arenaMarkerSet.HubGatePosition;
					arenaMarkerSet.HubGatePosition = position;
					break;
				case ArenaMarkerKind.EnemySpawn:
					first = arenaMarkerSet.EnemySpawnPositions[slot];
					arenaMarkerSet.EnemySpawnPositions[slot] = position;
					break;
				default:
					return false;
				}
				if (SamePosition(first, position))
				{
					return true;
				}
				value.Markers = arenaMarkerSet;
				if (kind != ArenaMarkerKind.HubGate)
				{
					value.Enabled = false;
				}
				value.Revision = Math.Max(1L, value.Revision + 1);
				return true;
			}
		}

		internal static bool RemoveMarker(string arenaId, ArenaMarkerKind kind, int slot)
		{
			arenaId = NormalizeId(arenaId);
			if (arenaId == null || !MarkerSlotIsValid(kind, slot))
			{
				return false;
			}
			lock (Sync)
			{
				if (!Arenas.TryGetValue(arenaId, out var value))
				{
					return false;
				}
				ArenaMarkerSet arenaMarkerSet = CopyOrCreatePartialMarkers(value.Markers);
				PositionData positionData = UnsetMarkerPosition();
				PositionData position;
				switch (kind)
				{
				case ArenaMarkerKind.Staging:
					position = arenaMarkerSet.StagingPosition;
					arenaMarkerSet.StagingPosition = positionData;
					break;
				case ArenaMarkerKind.CombatantStart:
					position = arenaMarkerSet.CombatantStartPosition;
					arenaMarkerSet.CombatantStartPosition = positionData;
					break;
				case ArenaMarkerKind.HubGate:
					position = arenaMarkerSet.HubGatePosition;
					arenaMarkerSet.HubGatePosition = positionData;
					break;
				case ArenaMarkerKind.EnemySpawn:
					position = arenaMarkerSet.EnemySpawnPositions[slot];
					arenaMarkerSet.EnemySpawnPositions[slot] = positionData;
					break;
				default:
					return false;
				}
				if (IsUnsetMarker(position))
				{
					return true;
				}
				value.Markers = arenaMarkerSet;
				if (kind != ArenaMarkerKind.HubGate)
				{
					value.Enabled = false;
				}
				value.Revision = Math.Max(1L, value.Revision + 1);
				return true;
			}
		}

		internal static int NextAvailableEnemyMarkerSlot(string arenaId)
		{
			arenaId = NormalizeId(arenaId);
			lock (Sync)
			{
				if (arenaId == null || !Arenas.TryGetValue(arenaId, out var value))
				{
					return -1;
				}
				ArenaMarkerSet arenaMarkerSet = CopyOrCreatePartialMarkers(value.Markers);
				for (int i = 0; i < arenaMarkerSet.EnemySpawnPositions.Count; i++)
				{
					if (IsUnsetMarker(arenaMarkerSet.EnemySpawnPositions[i]))
					{
						return i;
					}
				}
				return -1;
			}
		}

		internal static bool TryGetMarkerPosition(string arenaId, ArenaMarkerKind kind, int slot, out PositionData position)
		{
			arenaId = NormalizeId(arenaId);
			lock (Sync)
			{
				if (arenaId == null || !MarkerSlotIsValid(kind, slot) || !Arenas.TryGetValue(arenaId, out var value) || value.Markers == null)
				{
					position = default(PositionData);
					return false;
				}
				ArenaMarkerSet arenaMarkerSet = CopyOrCreatePartialMarkers(value.Markers);
				switch (kind)
				{
				case ArenaMarkerKind.Staging:
					position = arenaMarkerSet.StagingPosition;
					break;
				case ArenaMarkerKind.CombatantStart:
					position = arenaMarkerSet.CombatantStartPosition;
					break;
				case ArenaMarkerKind.HubGate:
					position = arenaMarkerSet.HubGatePosition;
					break;
				case ArenaMarkerKind.EnemySpawn:
					position = arenaMarkerSet.EnemySpawnPositions[slot];
					break;
				default:
					position = default(PositionData);
					return false;
				}
				return MarkerPositionIsSet(position);
			}
		}

		internal static bool MarkerPositionIsSet(PositionData position)
		{
			if (IsFinite(position))
			{
				return !IsUnsetMarker(position);
			}
			return false;
		}

		internal static bool IsWithinCombatRadius(ArenaDefinition arena, PositionData position)
		{
			if (arena != null && IsFinite(position) && !IsUnsetMarker(position) && IsFinitePositive(arena.CombatRadius))
			{
				return Contains(arena, position, arena.CombatRadius);
			}
			return false;
		}

		internal static PositionData UnsetMarkerPosition()
		{
			return new PositionData
			{
				X = float.MaxValue,
				Y = float.MaxValue,
				Z = float.MaxValue
			};
		}

		internal static bool RegisterGate(ArenaGateDefinition definition)
		{
			ArenaGateDefinition candidate = NormalizeAndCopyGate(definition);
			lock (Sync)
			{
				if (!Arenas.ContainsKey(candidate.ArenaId))
				{
					return false;
				}
				if (GateNames.TryGetValue(candidate.NormalizedName, out var value) && !string.Equals(value, candidate.GateId, StringComparison.Ordinal))
				{
					return false;
				}
				if (Gates.TryGetValue(candidate.GateId, out var value2))
				{
					GateNames.Remove(value2.NormalizedName);
				}
				if (candidate.IsFallbackEntrance)
				{
					foreach (ArenaGateDefinition item in Gates.Values.Where((ArenaGateDefinition gate) => string.Equals(gate.ArenaId, candidate.ArenaId, StringComparison.Ordinal)))
					{
						item.IsFallbackEntrance = false;
					}
				}
				Gates[candidate.GateId] = candidate;
				GateNames[candidate.NormalizedName] = candidate.GateId;
				return true;
			}
		}

		internal static bool RemoveGate(string gateId)
		{
			gateId = NormalizeId(gateId);
			if (gateId == null)
			{
				return false;
			}
			lock (Sync)
			{
				if (!Gates.TryGetValue(gateId, out var value))
				{
					return false;
				}
				Gates.Remove(gateId);
				GateNames.Remove(value.NormalizedName);
				return true;
			}
		}

		internal static bool TryGetGate(string gateId, out ArenaGateDefinition definition)
		{
			gateId = NormalizeId(gateId);
			lock (Sync)
			{
				if (gateId != null && Gates.TryGetValue(gateId, out var value))
				{
					definition = CopyGate(value);
					return true;
				}
			}
			definition = null;
			return false;
		}

		internal static bool TryGetGateByName(string displayName, out ArenaGateDefinition definition)
		{
			string text = NormalizeName(displayName);
			lock (Sync)
			{
				if (text != null && GateNames.TryGetValue(text, out var value) && Gates.TryGetValue(value, out var value2))
				{
					definition = CopyGate(value2);
					return true;
				}
			}
			definition = null;
			return false;
		}

		internal static bool RecordRoute(PlayerArenaRoute route)
		{
			if (route == null || route.PlayerId <= 0)
			{
				return false;
			}
			string text = NormalizeId(route.ArenaId);
			string text2 = NormalizeId(route.OriginGateId);
			if (text == null || text2 == null)
			{
				return false;
			}
			lock (Sync)
			{
				if (!Arenas.ContainsKey(text) || !Gates.TryGetValue(text2, out var value) || !string.Equals(value.ArenaId, text, StringComparison.Ordinal))
				{
					return false;
				}
				Routes[route.PlayerId] = new PlayerArenaRoute
				{
					PlayerId = route.PlayerId,
					ArenaId = text,
					OriginGateId = text2,
					EnteredUtc = AsUtc((route.EnteredUtc == default(DateTime)) ? DateTime.UtcNow : route.EnteredUtc)
				};
				return true;
			}
		}

		internal static ArenaGateDefinition ResolveReturnGate(long playerId)
		{
			if (playerId <= 0)
			{
				return null;
			}
			lock (Sync)
			{
				if (!Routes.TryGetValue(playerId, out var route))
				{
					return null;
				}
				if (Gates.TryGetValue(route.OriginGateId, out var value) && string.Equals(value.ArenaId, route.ArenaId, StringComparison.Ordinal))
				{
					return CopyGate(value);
				}
				ArenaGateDefinition arenaGateDefinition = Gates.Values.Where((ArenaGateDefinition gate) => string.Equals(gate.ArenaId, route.ArenaId, StringComparison.Ordinal) && gate.IsFallbackEntrance).OrderBy<ArenaGateDefinition, string>((ArenaGateDefinition gate) => gate.NormalizedName, StringComparer.Ordinal).ThenBy<ArenaGateDefinition, string>((ArenaGateDefinition gate) => gate.GateId, StringComparer.Ordinal)
					.FirstOrDefault();
				return (arenaGateDefinition == null) ? null : CopyGate(arenaGateDefinition);
			}
		}

		internal static bool ClearRoute(long playerId)
		{
			lock (Sync)
			{
				return Routes.Remove(playerId);
			}
		}

		internal static bool TryGetRoute(long playerId, out PlayerArenaRoute route)
		{
			lock (Sync)
			{
				if (playerId > 0 && Routes.TryGetValue(playerId, out var value))
				{
					route = CopyRoute(value);
					return true;
				}
			}
			route = null;
			return false;
		}

		internal static void ReplaceQueue(IEnumerable<QueueEntry> entries)
		{
			lock (Sync)
			{
				Queues.Clear();
				foreach (string key in Arenas.Keys)
				{
					Queues[key] = new List<QueueEntry>();
				}
				if (entries == null)
				{
					return;
				}
				foreach (QueueEntry entry in from queueEntry in entries.Where(IsValidQueueEntry)
					orderby queueEntry.QueueSequence, queueEntry.EnqueuedUtc
					select queueEntry)
				{
					string text = NormalizeId(entry.Request.ArenaId);
					if (Arenas.ContainsKey(text) && QueueOriginIsValid(entry, text))
					{
						if (!Queues.TryGetValue(text, out var value))
						{
							value = (Queues[text] = new List<QueueEntry>());
						}
						if (!value.Any((QueueEntry queueEntry) => queueEntry.Request.PlayerId == entry.Request.PlayerId))
						{
							value.Add(CopyQueueEntry(entry));
						}
					}
				}
			}
		}

		internal static List<QueueEntry> GetQueueSnapshot(string arenaId = null)
		{
			arenaId = (string.IsNullOrWhiteSpace(arenaId) ? null : NormalizeId(arenaId));
			lock (Sync)
			{
				IEnumerable<QueueEntry> source;
				if (arenaId != null)
				{
					if (!Queues.TryGetValue(arenaId, out var value))
					{
						source = Enumerable.Empty<QueueEntry>();
					}
					else
					{
						IEnumerable<QueueEntry> enumerable = value;
						source = enumerable;
					}
				}
				else
				{
					source = Queues.Values.SelectMany((List<QueueEntry> queue) => queue);
				}
				return (from entry in source
					orderby entry.QueueSequence, entry.EnqueuedUtc
					select entry).Select(CopyQueueEntry).ToList();
			}
		}

		internal static void SetActiveSession(ArenaSession session)
		{
			if (session == null)
			{
				throw new ArgumentNullException("session");
			}
			string text = RequireId(session.ArenaId, "ArenaId");
			lock (Sync)
			{
				if (!Arenas.ContainsKey(text))
				{
					throw new InvalidOperationException("Unknown arena '" + text + "'.");
				}
				ActiveSessions[text] = CopySession(session);
			}
		}

		internal static bool TryGetActiveSession(string arenaId, out ArenaSession session)
		{
			arenaId = NormalizeId(arenaId);
			lock (Sync)
			{
				if (arenaId != null && ActiveSessions.TryGetValue(arenaId, out var value))
				{
					session = CopySession(value);
					return true;
				}
			}
			session = null;
			return false;
		}

		internal static bool TryGetActiveSessionForPlayer(long playerId, out ArenaSession session)
		{
			lock (Sync)
			{
				ArenaSession arenaSession = ActiveSessions.Values.FirstOrDefault((ArenaSession active) => active != null && active.Request?.PlayerId == playerId);
				if (arenaSession != null)
				{
					session = CopySession(arenaSession);
					return true;
				}
			}
			session = null;
			return false;
		}

		internal static bool ClearActiveSession(string arenaId)
		{
			arenaId = NormalizeId(arenaId);
			lock (Sync)
			{
				return arenaId != null && ActiveSessions.Remove(arenaId);
			}
		}

		internal static List<ArenaDefinition> GetArenaSnapshot()
		{
			lock (Sync)
			{
				return Arenas.Values.OrderBy<ArenaDefinition, string>((ArenaDefinition arena) => arena.NormalizedName, StringComparer.Ordinal).Select(CopyArena).ToList();
			}
		}

		internal static List<ArenaGateDefinition> GetGateSnapshot()
		{
			lock (Sync)
			{
				return Gates.Values.OrderBy<ArenaGateDefinition, string>((ArenaGateDefinition gate) => gate.NormalizedName, StringComparer.Ordinal).Select(CopyGate).ToList();
			}
		}

		internal static List<ArenaGateDefinition> GetGatesForArena(string arenaId)
		{
			arenaId = NormalizeId(arenaId);
			lock (Sync)
			{
				if (arenaId == null)
				{
					return new List<ArenaGateDefinition>();
				}
				return Gates.Values.Where((ArenaGateDefinition gate) => string.Equals(gate.ArenaId, arenaId, StringComparison.Ordinal)).OrderBy<ArenaGateDefinition, string>((ArenaGateDefinition gate) => gate.NormalizedName, StringComparer.Ordinal).Select(CopyGate)
					.ToList();
			}
		}

		internal static List<PlayerArenaRoute> GetRouteSnapshot()
		{
			lock (Sync)
			{
				return Routes.Values.OrderBy((PlayerArenaRoute route) => route.PlayerId).Select(CopyRoute).ToList();
			}
		}

		internal static void Replace(PersistedWorldState state)
		{
			lock (Sync)
			{
				Arenas.Clear();
				ArenaNames.Clear();
				Gates.Clear();
				GateNames.Clear();
				Routes.Clear();
				Queues.Clear();
				ActiveSessions.Clear();
				if (state == null)
				{
					return;
				}
				foreach (ArenaDefinition item in state.Arenas ?? new List<ArenaDefinition>())
				{
					ArenaDefinition arenaDefinition = NormalizeAndCopyArena(item, validateEnabled: true);
					if (Arenas.ContainsKey(arenaDefinition.ArenaId) || ArenaNames.ContainsKey(arenaDefinition.NormalizedName))
					{
						throw new InvalidOperationException("Saved arena IDs and names must be unique.");
					}
					Arenas.Add(arenaDefinition.ArenaId, arenaDefinition);
					ArenaNames.Add(arenaDefinition.NormalizedName, arenaDefinition.ArenaId);
					Queues.Add(arenaDefinition.ArenaId, new List<QueueEntry>());
				}
				foreach (ArenaGateDefinition item2 in state.Gates ?? new List<ArenaGateDefinition>())
				{
					ArenaGateDefinition arenaGateDefinition = NormalizeAndCopyGate(item2);
					if (!Arenas.ContainsKey(arenaGateDefinition.ArenaId) || Gates.ContainsKey(arenaGateDefinition.GateId) || GateNames.ContainsKey(arenaGateDefinition.NormalizedName))
					{
						throw new InvalidOperationException("Saved gates must target an arena and have unique IDs and names.");
					}
					Gates.Add(arenaGateDefinition.GateId, arenaGateDefinition);
					GateNames.Add(arenaGateDefinition.NormalizedName, arenaGateDefinition.GateId);
				}
				foreach (PlayerArenaRoute item3 in state.Routes ?? new List<PlayerArenaRoute>())
				{
					if (!RecordRouteWhileLocked(item3))
					{
						throw new InvalidOperationException("Saved player route does not target a valid arena entrance.");
					}
				}
				foreach (QueueEntry raw in from entry in state.Queue ?? new List<QueueEntry>()
					orderby entry.QueueSequence, entry.EnqueuedUtc
					select entry)
				{
					if (!IsValidQueueEntry(raw))
					{
						throw new InvalidOperationException("Saved queue contains an invalid entry.");
					}
					string text = NormalizeId(raw.Request.ArenaId);
					if (!Arenas.ContainsKey(text) || !QueueOriginIsValid(raw, text))
					{
						throw new InvalidOperationException("Saved queue targets an unknown arena or entrance.");
					}
					List<QueueEntry> list = Queues[text];
					if (list.Any((QueueEntry entry) => entry.Request.PlayerId == raw.Request.PlayerId))
					{
						throw new InvalidOperationException("A player occurs more than once in an arena queue.");
					}
					list.Add(CopyQueueEntry(raw));
				}
			}
		}

		internal static void Clear()
		{
			Replace(null);
		}

		internal static PersistedWorldState Snapshot(long worldUid, long rosterRevision, IEnumerable<ArenaSession> interruptedSessions, IEnumerable<LeaderboardEntry> leaderboard)
		{
			lock (Sync)
			{
				return new PersistedWorldState
				{
					WorldUid = worldUid,
					RosterRevision = rosterRevision,
					Arenas = Arenas.Values.OrderBy<ArenaDefinition, string>((ArenaDefinition arena) => arena.NormalizedName, StringComparer.Ordinal).Select(CopyArena).ToList(),
					Gates = Gates.Values.OrderBy<ArenaGateDefinition, string>((ArenaGateDefinition gate) => gate.NormalizedName, StringComparer.Ordinal).Select(CopyGate).ToList(),
					Routes = Routes.Values.OrderBy((PlayerArenaRoute route) => route.PlayerId).Select(CopyRoute).ToList(),
					Queue = (from entry in Queues.Values.SelectMany((List<QueueEntry> queue) => queue)
						orderby entry.QueueSequence, entry.EnqueuedUtc
						select entry).Select(CopyQueueEntry).ToList(),
					InterruptedSessions = (interruptedSessions ?? Enumerable.Empty<ArenaSession>()).Select(CopySession).ToList(),
					Leaderboard = (leaderboard ?? Enumerable.Empty<LeaderboardEntry>()).Select(CopyLeaderboardEntry).ToList()
				};
			}
		}

		internal static string NormalizeName(string value)
		{
			if (string.IsNullOrWhiteSpace(value))
			{
				return null;
			}
			string text = value.Trim();
			if (text.Length > 64)
			{
				throw new ArgumentException("Arena and gate names are limited to 64 characters.");
			}
			return text.ToLowerInvariant();
		}

		internal static string NormalizeId(string value)
		{
			if (string.IsNullOrWhiteSpace(value) || !Guid.TryParse(value.Trim(), out var result))
			{
				return null;
			}
			return result.ToString("N").ToLowerInvariant();
		}

		private static ArenaDefinition FindContainingArena(PositionData position, bool combat)
		{
			return (from arena in Arenas.Values
				where (!combat || arena.Enabled) && Contains(arena, position, combat ? arena.CombatRadius : arena.ProtectedRadius)
				orderby DistanceSquaredXZ(arena.CorePosition, position)
				select arena).ThenBy<ArenaDefinition, string>((ArenaDefinition arena) => arena.ArenaId, StringComparer.Ordinal).FirstOrDefault();
		}

		private static bool Contains(ArenaDefinition arena, PositionData position, float radius)
		{
			return DistanceSquaredXZ(arena.CorePosition, position) <= radius * radius;
		}

		private static float DistanceSquaredXZ(PositionData first, PositionData second)
		{
			float num = first.X - second.X;
			float num2 = first.Z - second.Z;
			return num * num + num2 * num2;
		}

		private static ArenaDefinition NormalizeAndCopyArena(ArenaDefinition source, bool validateEnabled)
		{
			if (source == null)
			{
				throw new ArgumentNullException("source");
			}
			string arenaId = RequireId(source.ArenaId, "ArenaId");
			string text = NormalizeName(source.DisplayName);
			if (text == null)
			{
				throw new ArgumentException("Arena name is required.", "source");
			}
			if (!IsFinitePositive(source.CombatRadius) || !IsFinitePositive(source.ProtectedRadius) || source.ProtectedRadius <= source.CombatRadius)
			{
				throw new ArgumentException("ProtectedRadius must be finite and greater than CombatRadius.", "source");
			}
			if (!IsFinite(source.CorePosition))
			{
				throw new ArgumentException("Arena position must be finite.", "source");
			}
			if (validateEnabled && source.Enabled && !MarkersAreComplete(source.Markers))
			{
				throw new ArgumentException("The arena cannot be enabled. Missing: " + string.Join(", ", MissingRequiredMarkers(source.Markers)) + ". Gates are optional.", "source");
			}
			return new ArenaDefinition
			{
				ArenaId = arenaId,
				DisplayName = source.DisplayName.Trim(),
				NormalizedName = text,
				CorePosition = source.CorePosition,
				CombatRadius = source.CombatRadius,
				ProtectedRadius = source.ProtectedRadius,
				Markers = CopyMarkers(source.Markers),
				Enabled = source.Enabled,
				Revision = source.Revision
			};
		}

		private static ArenaGateDefinition NormalizeAndCopyGate(ArenaGateDefinition source)
		{
			if (source == null)
			{
				throw new ArgumentNullException("source");
			}
			string gateId = RequireId(source.GateId, "GateId");
			string arenaId = RequireId(source.ArenaId, "ArenaId");
			string text = NormalizeName(source.DisplayName);
			if (text == null)
			{
				throw new ArgumentException("Gate name is required.", "source");
			}
			if (!IsFinite(source.Position) || !IsFinite(source.RotationY))
			{
				throw new ArgumentException("Gate position and rotation must be finite.", "source");
			}
			return new ArenaGateDefinition
			{
				GateId = gateId,
				ArenaId = arenaId,
				DisplayName = source.DisplayName.Trim(),
				NormalizedName = text,
				Position = source.Position,
				RotationY = source.RotationY,
				IsFallbackEntrance = source.IsFallbackEntrance
			};
		}

		internal static bool MarkersAreComplete(ArenaMarkerSet markers)
		{
			if (markers != null && markers.EnemySpawnPositions != null && markers.EnemySpawnPositions.Count == 4 && MarkerPositionIsSet(markers.StagingPosition) && MarkerPositionIsSet(markers.CombatantStartPosition))
			{
				return markers.EnemySpawnPositions.All(MarkerPositionIsSet);
			}
			return false;
		}

		internal static List<string> MissingRequiredMarkers(ArenaMarkerSet markers)
		{
			List<string> list = new List<string>();
			if (markers == null || !MarkerPositionIsSet(markers.StagingPosition))
			{
				list.Add("Arena Master staging position");
			}
			if (markers == null || !MarkerPositionIsSet(markers.CombatantStartPosition))
			{
				list.Add("Combat Start");
			}
			for (int i = 0; i < 4; i++)
			{
				if (markers?.EnemySpawnPositions == null || markers.EnemySpawnPositions.Count <= i || !MarkerPositionIsSet(markers.EnemySpawnPositions[i]))
				{
					list.Add("Enemy Spawn " + (i + 1));
				}
			}
			return list;
		}

		private static ArenaMarkerSet CopyOrCreatePartialMarkers(ArenaMarkerSet source)
		{
			PositionData positionData = UnsetMarkerPosition();
			ArenaMarkerSet arenaMarkerSet = new ArenaMarkerSet
			{
				StagingPosition = (source?.StagingPosition ?? positionData),
				CombatantStartPosition = (source?.CombatantStartPosition ?? positionData),
				HubGatePosition = (source?.HubGatePosition ?? positionData),
				EnemySpawnPositions = ((source?.EnemySpawnPositions == null) ? new List<PositionData>() : new List<PositionData>(source.EnemySpawnPositions))
			};
			while (arenaMarkerSet.EnemySpawnPositions.Count < 4)
			{
				arenaMarkerSet.EnemySpawnPositions.Add(positionData);
			}
			if (arenaMarkerSet.EnemySpawnPositions.Count > 4)
			{
				arenaMarkerSet.EnemySpawnPositions.RemoveRange(4, arenaMarkerSet.EnemySpawnPositions.Count - 4);
			}
			return arenaMarkerSet;
		}

		private static bool MarkerSlotIsValid(ArenaMarkerKind kind, int slot)
		{
			switch (kind)
			{
			case ArenaMarkerKind.Staging:
			case ArenaMarkerKind.CombatantStart:
			case ArenaMarkerKind.HubGate:
				return slot == -1;
			case ArenaMarkerKind.EnemySpawn:
				if (slot >= 0)
				{
					return slot < 4;
				}
				return false;
			default:
				return false;
			}
		}

		private static bool IsUnsetMarker(PositionData position)
		{
			if (position.X == float.MaxValue && position.Y == float.MaxValue)
			{
				return position.Z == float.MaxValue;
			}
			return false;
		}

		private static bool SamePosition(PositionData first, PositionData second)
		{
			if (Math.Abs(first.X - second.X) < 0.001f && Math.Abs(first.Y - second.Y) < 0.001f)
			{
				return Math.Abs(first.Z - second.Z) < 0.001f;
			}
			return false;
		}

		private static bool IsFinite(PositionData 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;
		}

		private static bool IsFinitePositive(float value)
		{
			if (IsFinite(value))
			{
				return value > 0f;
			}
			return false;
		}

		private static string RequireId(string value, string parameterName)
		{
			return NormalizeId(value) ?? throw new ArgumentException("A lowercase GUID identifier is required.", parameterName);
		}

		private static bool IsValidQueueEntry(QueueEntry entry)
		{
			if (entry != null && entry.Request != null && entry.Request.PlayerId > 0 && NormalizeId(entry.Request.RequestId) != null && NormalizeId(entry.Request.ArenaId) != null)
			{
				return entry.QueueSequence >= 0;
			}
			return false;
		}

		private static bool QueueOriginIsValid(QueueEntry entry, string arenaId)
		{
			if (string.IsNullOrWhiteSpace(entry.OriginGateId))
			{
				return true;
			}
			string text = NormalizeId(entry.OriginGateId);
			if (text == null)
			{
				return false;
			}
			if (Gates.TryGetValue(text, out var value))
			{
				return string.Equals(value.ArenaId, arenaId, StringComparison.Ordinal);
			}
			return true;
		}

		private static bool RecordRouteWhileLocked(PlayerArenaRoute route)
		{
			if (route == null || route.PlayerId <= 0)
			{
				return false;
			}
			string text = NormalizeId(route.ArenaId);
			string text2 = NormalizeId(route.OriginGateId);
			if (text == null || text2 == null || !Arenas.ContainsKey(text))
			{
				return false;
			}
			if (Gates.TryGetValue(text2, out var value) && !string.Equals(value.ArenaId, text, StringComparison.Ordinal))
			{
				return false;
			}
			Routes[route.PlayerId] = new PlayerArenaRoute
			{
				PlayerId = route.PlayerId,
				ArenaId = text,
				OriginGateId = text2,
				EnteredUtc = AsUtc(route.EnteredUtc)
			};
			return true;
		}

		private static DateTime AsUtc(DateTime value)
		{
			if (value == default(DateTime))
			{
				return DateTime.SpecifyKind(value, DateTimeKind.Utc);
			}
			if (value.Kind != DateTimeKind.Utc)
			{
				return value.ToUniversalTime();
			}
			return value;
		}

		private static ArenaDefinition CopyArena(ArenaDefinition source)
		{
			if (source == null)
			{
				return null;
			}
			return new ArenaDefinition
			{
				ArenaId = source.ArenaId,
				DisplayName = source.DisplayName,
				NormalizedName = source.NormalizedName,
				CorePosition = source.CorePosition,
				CombatRadius = source.CombatRadius,
				ProtectedRadius = source.ProtectedRadius,
				Markers = CopyMarkers(source.Markers),
				Enabled = source.Enabled,
				Revision = source.Revision
			};
		}

		private static ArenaMarkerSet CopyMarkers(ArenaMarkerSet source)
		{
			if (source == null)
			{
				return null;
			}
			return new ArenaMarkerSet
			{
				StagingPosition = source.StagingPosition,
				CombatantStartPosition = source.CombatantStartPosition,
				HubGatePosition = source.HubGatePosition,
				EnemySpawnPositions = ((source.EnemySpawnPositions == null) ? new List<PositionData>() : new List<PositionData>(source.EnemySpawnPositions))
			};
		}

		private static ArenaGateDefinition CopyGate(ArenaGateDefinition source)
		{
			if (source == null)
			{
				return null;
			}
			return new ArenaGateDefinition
			{
				GateId = source.GateId,
				ArenaId = source.ArenaId,
				DisplayName = source.DisplayName,
				NormalizedName = source.NormalizedName,
				Position = source.Position,
				RotationY = source.RotationY,
				IsFallbackEntrance = source.IsFallbackEntrance
			};
		}

		private static PlayerArenaRoute CopyRoute(PlayerArenaRoute source)
		{
			if (source != null)
			{
				return new PlayerArenaRoute
				{
					PlayerId = source.PlayerId,
					ArenaId = source.ArenaId,
					OriginGateId = source.OriginGateId,
					EnteredUtc = source.EnteredUtc
				};
			}
			return null;
		}

		private static QueueEntry CopyQueueEntry(QueueEntry source)
		{
			if (source == null)
			{
				return null;
			}
			return new QueueEntry
			{
				Request = CopyRequest(source.Request),
				OriginGateId = source.OriginGateId,
				QueueSequence = source.QueueSequence,
				EnqueuedUtc = source.EnqueuedUtc
			};
		}

		private static ChallengeRequest CopyRequest(ChallengeRequest source)
		{
			if (source == null)
			{
				return null;
			}
			return new ChallengeRequest
			{
				RequestId = source.RequestId,
				ArenaId = source.ArenaId,
				PlayerId = source.PlayerId,
				PlayerName = source.PlayerName,
				Mode = source.Mode,
				CapMode = source.CapMode,
				SelectedBiome = source.SelectedBiome,
				RequestedUtc = source.RequestedUtc,
				CustomSelection = ((source.CustomSelection == null) ? null : new CustomEncounterSelection
				{
					CreatureKey = source.CustomSelection.CreatureKey,
					Stars = source.CustomSelection.Stars,
					Quantity = source.CustomSelection.Quantity
				})
			};
		}

		private static ArenaSession CopySession(ArenaSession source)
		{
			if (source == null)
			{
				return null;
			}
			return new ArenaSession
			{
				SessionId = source.SessionId,
				ArenaId = source.ArenaId,
				Request = CopyRequest(source.Request),
				Plan = CopyPlan(source.Plan),
				Phase = source.Phase,
				Outcome = source.Outcome,
				EncounterIndex = source.EncounterIndex,
				LivingArenaEnemyCount = source.LivingArenaEnemyCount,
				SpawnedEnemyIds = ((source.SpawnedEnemyIds == null) ? new List<string>() : new List<string>(source.SpawnedEnemyIds)),
				ResourceSnapshot = CopyResourceSnapshot(source.ResourceSnapshot),
				PhaseStartedUtc = source.PhaseStartedUtc,
				PhaseDeadlineUtc = source.PhaseDeadlineUtc,
				SessionStartedUtc = source.SessionStartedUtc,
				ElapsedMilliseconds = source.ElapsedMilliseconds
			};
		}

		private static ChallengePlan CopyPlan(ChallengePlan source)
		{
			if (source == null)
			{
				return null;
			}
			return new ChallengePlan
			{
				PlanId = source.PlanId,
				Mode = source.Mode,
				CapMode = source.CapMode,
				HighestBiome = source.HighestBiome,
				RosterRevision = source.RosterRevision,
				Encounters = ((source.Encounters == null) ? new List<EncounterDefinition>() : source.Encounters.Select(CopyEncounter).ToList())
			};
		}

		private static EncounterDefinition CopyEncounter(EncounterDefinition source)
		{
			if (source == null)
			{
				return null;
			}
			return new EncounterDefinition
			{
				Sequence = source.Sequence,
				CreatureKey = source.CreatureKey,
				Biome = source.Biome,
				Stars = source.Stars,
				Quantity = source.Quantity,
				IsMiniboss = source.IsMiniboss,
				PreparationSeconds = source.PreparationSeconds
			};
		}

		private static PlayerResourceSnapshot CopyResourceSnapshot(PlayerResourceSnapshot source)
		{
			if (source == null)
			{
				return null;
			}
			return new PlayerResourceSnapshot
			{
				PlayerId = source.PlayerId,
				Foods = ((source.Foods == null) ? new List<FoodStateSnapshot>() : source.Foods.Select((FoodStateSnapshot food) => new FoodStateSnapshot
				{
					ItemPrefabName = food.ItemPrefabName,
					RemainingSeconds = food.RemainingSeconds,
					Health = food.Health,
					Stamina = food.Stamina,
					Eitr = food.Eitr
				}).ToList()),
				RestedRemainingSeconds = source.RestedRemainingSeconds,
				ArenaFoodPrefabNames = ((source.ArenaFoodPrefabNames == null) ? new List<string>() : new List<string>(source.ArenaFoodPrefabNames)),
				AllowedConsumableCounts = ((source.AllowedConsumableCounts == null) ? new Dictionary<string, int>() : new Dictionary<string, int>(source.AllowedConsumableCounts, StringComparer.Ordinal)),
				AmmunitionCounts = ((source.AmmunitionCounts == null) ? new Dictionary<string, int>() : new Dictionary<string, int>(source.AmmunitionCounts, StringComparer.Ordinal)),
				EquipmentDurabilityBySlot = ((source.EquipmentDurabilityBySlot == null) ? new Dictionary<string, float>() : new Dictionary<string, float>(source.EquipmentDurabilityBySlot, StringComparer.Ordinal)),
				CapturedUtc = source.CapturedUtc
			};
		}

		private static LeaderboardEntry CopyLeaderboardEntry(LeaderboardEntry source)
		{
			if (source == null)
			{
				return null;
			}
			return new LeaderboardEntry
			{
				Key = ((source.Key == null) ? null : new LeaderboardKey
				{
					Mode = source.Key.Mode,
					CapMode = source.Key.CapMode,
					SelectedBiome = source.Key.SelectedBiome,
					CustomCreatureKey = source.Key.CustomCreatureKey,
					CustomStars = source.Key.CustomStars,
					CustomQuantity = source.Key.CustomQuantity
				}),
				PlayerId = source.PlayerId,
				PlayerName = source.PlayerName,
				Completed = source.Completed,
				FurthestEncounterIndex = source.FurthestEncounterIndex,
				ElapsedMilliseconds = source.ElapsedMilliseconds,
				RosterRevision = source.RosterRevision,
				RecordedUtc = source.RecordedUtc
			};
		}
	}
}