using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HoldfastGame;
using Microsoft.CodeAnalysis;
using UnityEngine;
using UnityEngine.Rendering;
using UnityEngine.SceneManagement;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyVersion("1.0.0.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 AdminHelper
{
	[BepInPlugin("com.ryannlt.adminhelper", "AdminHelper", "1.0.0")]
	public class AdminHelperMod : BaseUnityPlugin
	{
		public const string Guid = "com.ryannlt.adminhelper";

		private readonly IsolationTracker _tracker = new IsolationTracker();

		private readonly RingRenderer _rings = new RingRenderer();

		private readonly Hotkey _hotkey = new Hotkey();

		private readonly Hud _hud = new Hud();

		private Driver _driver;

		private float _accumulator;

		private bool _wasInRound;

		private void Awake()
		{
			//IL_0037: 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)
			Settings.Create(((BaseUnityPlugin)this).Config);
			_hotkey.ResetToDefault();
			SceneManager.sceneLoaded += OnSceneLoaded;
			EnsureDriver();
			Log.Info("Ready. Toggle key " + ((object)Settings.ResolveToggleKey()/*cast due to .constrained prefix*/).ToString() + ", RequireAdminLogin=" + Settings.RequireAdminLogin.Value);
		}

		private void OnDestroy()
		{
			Log.Info("plugin component destroyed");
		}

		private void OnSceneLoaded(Scene scene, LoadSceneMode mode)
		{
			Log.Info("scene loaded " + ((Scene)(ref scene)).name + " driverAlive=" + ((Object)(object)_driver != (Object)null));
			EnsureDriver();
			GameAccess.ClearSceneCache();
			_tracker.Reset();
			_rings.Destroy();
			_accumulator = 0f;
			_wasInRound = false;
		}

		private void EnsureDriver()
		{
			if (!((Object)(object)_driver != (Object)null))
			{
				_driver = Driver.Attach(this);
			}
		}

		internal void Tick()
		{
			Settings.PollForExternalEdits();
			if (!Settings.Enabled.Value)
			{
				_rings.HideAll();
				return;
			}
			_hotkey.Poll();
			if (!GameAccess.InRound)
			{
				if (_wasInRound)
				{
					_tracker.Reset();
				}
				_wasInRound = false;
				_rings.HideAll();
				return;
			}
			_wasInRound = true;
			_accumulator += Time.deltaTime;
			float num = 1f / Mathf.Clamp(Settings.TickHz.Value, 1f, 30f);
			if (_accumulator >= num)
			{
				_tracker.Tick(_accumulator);
				_accumulator = 0f;
			}
			if (CanReveal() && _hotkey.Visible && Settings.ShowRings.Value)
			{
				_rings.Draw(_tracker.Watched);
			}
			else
			{
				_rings.HideAll();
			}
		}

		internal void DrawGui()
		{
			if (Settings.Enabled.Value && _hotkey.Visible && GameAccess.InRound)
			{
				_hud.Draw(_tracker, CanReveal());
			}
		}

		private static bool CanReveal()
		{
			return !Settings.RequireAdminLogin.Value || GameAccess.IsLoggedInAdmin;
		}
	}
	internal sealed class Driver : MonoBehaviour
	{
		internal AdminHelperMod Owner;

		internal static Driver Attach(AdminHelperMod owner)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			GameObject val = new GameObject("AdminHelper_Driver");
			Object.DontDestroyOnLoad((Object)(object)val);
			Driver driver = val.AddComponent<Driver>();
			driver.Owner = owner;
			return driver;
		}

		private void Awake()
		{
			Log.Info("driver awake");
		}

		private void OnDestroy()
		{
			Log.Info("driver destroyed");
		}

		private void Update()
		{
			if (Owner != null)
			{
				Owner.Tick();
			}
		}

		private void OnGUI()
		{
			if (Owner != null)
			{
				Owner.DrawGui();
			}
		}
	}
	internal static class FormationDetector
	{
		private const int MaxScratch = 16;

		private static readonly float[] ScratchX = new float[16];

		private static readonly float[] ScratchZ = new float[16];

		private static readonly float[] ScratchDistanceSquared = new float[16];

		public static bool IsInFormation(PlayerSnapshot self, List<PlayerSnapshot> friendlies)
		{
			if (GameAccess.IsInsideOfficerLine(self.Player))
			{
				return true;
			}
			int num = CollectNearest(self, friendlies, Settings.LineRadius.Value, Settings.LineMaxMates.Value);
			if (CountWithin(num, Settings.ClusterFormationRadius.Value) >= Settings.ClusterMinMates.Value)
			{
				return true;
			}
			if (num < Settings.LineMinMates.Value)
			{
				return false;
			}
			return PerpendicularSpread(self, num) <= Settings.LineResidual.Value;
		}

		private static int CollectNearest(PlayerSnapshot self, List<PlayerSnapshot> friendlies, float radius, int max)
		{
			//IL_0041: 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_005b: 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_012d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0141: Unknown result type (might be due to invalid IL or missing references)
			if (max > 16)
			{
				max = 16;
			}
			float num = radius * radius;
			int num2 = 0;
			for (int i = 0; i < friendlies.Count; i++)
			{
				PlayerSnapshot playerSnapshot = friendlies[i];
				if (playerSnapshot.PlayerId == self.PlayerId)
				{
					continue;
				}
				float num3 = playerSnapshot.Position.x - self.Position.x;
				float num4 = playerSnapshot.Position.z - self.Position.z;
				float num5 = num3 * num3 + num4 * num4;
				if (!(num5 > num) && (num2 != max || !(num5 >= ScratchDistanceSquared[num2 - 1])))
				{
					int num6 = ((num2 < max) ? num2 : (num2 - 1));
					while (num6 > 0 && ScratchDistanceSquared[num6 - 1] > num5)
					{
						ScratchDistanceSquared[num6] = ScratchDistanceSquared[num6 - 1];
						ScratchX[num6] = ScratchX[num6 - 1];
						ScratchZ[num6] = ScratchZ[num6 - 1];
						num6--;
					}
					ScratchDistanceSquared[num6] = num5;
					ScratchX[num6] = playerSnapshot.Position.x;
					ScratchZ[num6] = playerSnapshot.Position.z;
					if (num2 < max)
					{
						num2++;
					}
				}
			}
			return num2;
		}

		private static int CountWithin(int count, float radius)
		{
			float num = radius * radius;
			for (int i = 0; i < count; i++)
			{
				if (ScratchDistanceSquared[i] > num)
				{
					return i;
				}
			}
			return count;
		}

		private static float PerpendicularSpread(PlayerSnapshot self, int count)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: 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_0079: Unknown result type (might be due to invalid IL or missing references)
			int num = count + 1;
			float num2 = self.Position.x;
			float num3 = self.Position.z;
			for (int i = 0; i < count; i++)
			{
				num2 += ScratchX[i];
				num3 += ScratchZ[i];
			}
			float num4 = num2 / (float)num;
			float num5 = num3 / (float)num;
			float xx = 0f;
			float xz = 0f;
			float zz = 0f;
			AccumulateCovariance(self.Position.x - num4, self.Position.z - num5, ref xx, ref xz, ref zz);
			for (int j = 0; j < count; j++)
			{
				AccumulateCovariance(ScratchX[j] - num4, ScratchZ[j] - num5, ref xx, ref xz, ref zz);
			}
			float num6 = xx + zz;
			float num7 = xx - zz;
			float num8 = Mathf.Sqrt(num7 * num7 + 4f * xz * xz);
			float num9 = Mathf.Max(0f, (num6 - num8) * 0.5f);
			return Mathf.Sqrt(num9 / (float)num);
		}

		private static void AccumulateCovariance(float dx, float dz, ref float xx, ref float xz, ref float zz)
		{
			xx += dx * dx;
			xz += dx * dz;
			zz += dz * dz;
		}
	}
	internal static class GameAccess
	{
		private static GameConsolePanel _consolePanel;

		private static float _nextConsoleLookup;

		public static ClientComponentReferenceManager Client => ClientComponentReferenceManager.ClientInstance;

		public static bool IsLoggedInAdmin => ClientRemoteConsoleAccessManager.loggedOn;

		public static bool InRound
		{
			get
			{
				ClientComponentReferenceManager client = Client;
				return (Object)(object)client != (Object)null && (Object)(object)client.clientRoundPlayerManager != (Object)null;
			}
		}

		public static Camera ActiveCamera
		{
			get
			{
				ClientComponentReferenceManager client = Client;
				if ((Object)(object)client == (Object)null || (Object)(object)client.ownerCameraManager == (Object)null)
				{
					return null;
				}
				Camera val = client.ownerCameraManager.ActiveCamera;
				if ((Object)(object)val == (Object)null)
				{
					val = client.ownerCameraManager.ownerCamera;
				}
				return val;
			}
		}

		public static int LocalPlayerId
		{
			get
			{
				ClientComponentReferenceManager client = Client;
				if ((Object)(object)client == (Object)null || (Object)(object)client.clientRoundPlayerManager == (Object)null)
				{
					return -1;
				}
				return ((RoundPlayer)(client.clientRoundPlayerManager.LocalPlayer?)).NetworkPlayerID ?? (-1);
			}
		}

		public static bool IsTyping
		{
			get
			{
				ClientComponentReferenceManager client = Client;
				if ((Object)(object)client != (Object)null && (Object)(object)client.clientChatHandler != (Object)null && client.clientChatHandler.isChatPaneOpened)
				{
					return true;
				}
				if ((Object)(object)_consolePanel == (Object)null && Time.unscaledTime >= _nextConsoleLookup)
				{
					_nextConsoleLookup = Time.unscaledTime + 2f;
					_consolePanel = Object.FindObjectOfType<GameConsolePanel>();
				}
				return (Object)(object)_consolePanel != (Object)null && _consolePanel.Showing;
			}
		}

		public static void ClearSceneCache()
		{
			_consolePanel = null;
			_nextConsoleLookup = 0f;
		}

		public static void CollectPlayers(List<PlayerSnapshot> into)
		{
			into.Clear();
			ClientComponentReferenceManager client = Client;
			if ((Object)(object)client == (Object)null)
			{
				return;
			}
			ClientRoundPlayerManager clientRoundPlayerManager = client.clientRoundPlayerManager;
			if ((Object)(object)clientRoundPlayerManager == (Object)null)
			{
				return;
			}
			List<ClientRoundPlayerProxy> roundPlayersList = clientRoundPlayerManager.roundPlayersList;
			for (int i = 0; i < roundPlayersList.Count; i++)
			{
				if (TrySnapshot((RoundPlayer)(object)roundPlayersList[i], out var snapshot))
				{
					into.Add(snapshot);
				}
			}
			if (TrySnapshot((RoundPlayer)(object)clientRoundPlayerManager.LocalPlayer, out var snapshot2))
			{
				into.Add(snapshot2);
			}
		}

		private static bool TrySnapshot(RoundPlayer player, out PlayerSnapshot snapshot)
		{
			//IL_007e: 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_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: 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_00a5: Unknown result type (might be due to invalid IL or missing references)
			snapshot = default(PlayerSnapshot);
			if (player == null || (Object)(object)player.PlayerBase == (Object)null || !player.PlayerBase.SpawnedAndAlive)
			{
				return false;
			}
			if (player.PlayerTransformData == null || player.PlayerStartData == null)
			{
				return false;
			}
			PlayerBase playerBase = player.PlayerBase;
			snapshot.Player = player;
			snapshot.PlayerId = player.NetworkPlayerID;
			snapshot.Name = ResolveName(player);
			snapshot.Position = player.PlayerTransformData.position;
			snapshot.Faction = player.PlayerStartData.Faction;
			snapshot.Class = player.PlayerStartData.ClassType;
			snapshot.IsCavalry = playerBase.IsCavalry;
			snapshot.IsArtillery = playerBase.IsArty;
			return true;
		}

		private static string ResolveName(RoundPlayer player)
		{
			RoundPlayerInformation playerRoundInformation = player.PlayerRoundInformation;
			if (playerRoundInformation == null || playerRoundInformation.InitialDetails == null)
			{
				return "Player " + player.NetworkPlayerID;
			}
			PlayerInitialDetails initialDetails = playerRoundInformation.InitialDetails;
			string text = (string.IsNullOrEmpty(initialDetails.DisplayName) ? initialDetails.Name : initialDetails.DisplayName);
			if (string.IsNullOrEmpty(text))
			{
				return "Player " + player.NetworkPlayerID;
			}
			return text;
		}

		public static bool IsInsideOfficerLine(RoundPlayer player)
		{
			ClientComponentReferenceManager client = Client;
			if ((Object)(object)client == (Object)null || (Object)(object)client.clientHighCommandOrderManager == (Object)null)
			{
				return false;
			}
			return ((HighCommandOrderManager)client.clientHighCommandOrderManager).IsPlayerInsideAnyOfficerLine(player);
		}
	}
	internal sealed class Hotkey
	{
		private bool _visible;

		public bool Visible => _visible;

		public void ResetToDefault()
		{
			_visible = Settings.StartHudVisible.Value;
		}

		public void Poll()
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			if (!GameAccess.IsTyping && Input.GetKeyDown(Settings.ResolveToggleKey()))
			{
				_visible = !_visible;
			}
		}
	}
	internal sealed class Hud
	{
		private static readonly Color WatchColour = new Color(1f, 0.82f, 0.15f);

		private static readonly Color FlagColour = new Color(1f, 0.35f, 0.25f);

		private static readonly Color InfoColour = new Color(0.85f, 0.88f, 0.92f);

		private static readonly Color PanelColour = new Color(0.05f, 0.05f, 0.06f, 0.78f);

		private readonly List<ScoredPlayer> _sorted = new List<ScoredPlayer>();

		private GUIStyle _labelStyle;

		private GUIStyle _listStyle;

		private Texture2D _panelTexture;

		public void Draw(IsolationTracker tracker, bool revealOthers)
		{
			EnsureStyles();
			_sorted.Clear();
			if (revealOthers)
			{
				SortByHeat(tracker.Watched);
				if (Settings.ShowLabels.Value)
				{
					DrawLabels();
				}
			}
			if (Settings.ShowCornerList.Value)
			{
				DrawCornerList(revealOthers);
			}
			if (Settings.ShowOwnScore.Value && tracker.HasLocalScore)
			{
				DrawOwnScore(tracker.LocalScore);
			}
		}

		private void DrawLabels()
		{
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: 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)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0117: Unknown result type (might be due to invalid IL or missing references)
			//IL_011e: Expected O, but got Unknown
			//IL_0126: Unknown result type (might be due to invalid IL or missing references)
			//IL_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0137: 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_0151: Unknown result type (might be due to invalid IL or missing references)
			//IL_0165: Unknown result type (might be due to invalid IL or missing references)
			//IL_016d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0175: Unknown result type (might be due to invalid IL or missing references)
			//IL_017c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0188: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b1: 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_01bc: Unknown result type (might be due to invalid IL or missing references)
			Camera activeCamera = GameAccess.ActiveCamera;
			if ((Object)(object)activeCamera == (Object)null)
			{
				return;
			}
			int num = Mathf.Min(_sorted.Count, Mathf.Max(0, Settings.MaxLabels.Value));
			Rect val4 = default(Rect);
			for (int i = 0; i < num; i++)
			{
				ScoredPlayer scoredPlayer = _sorted[i];
				Vector3 val = activeCamera.WorldToScreenPoint(scoredPlayer.Position + Vector3.up * 2.1f);
				if (!(val.z <= 0f))
				{
					string text = (scoredPlayer.Flagged ? ("RAMBO: " + Mathf.FloorToInt(scoredPlayer.DwellSeconds) + "s") : "ISOLATED");
					string text2 = scoredPlayer.Name + "\n" + text + "\nISO: " + scoredPlayer.Isolation + "  DGR: " + scoredPlayer.Danger;
					GUIContent val2 = new GUIContent(text2);
					Vector2 val3 = _labelStyle.CalcSize(val2);
					val3.y = _labelStyle.CalcHeight(val2, val3.x);
					((Rect)(ref val4))..ctor(val.x - val3.x * 0.5f, (float)Screen.height - val.y - val3.y, val3.x, val3.y);
					GUI.DrawTexture(val4, (Texture)(object)_panelTexture);
					_labelStyle.normal.textColor = (scoredPlayer.Flagged ? FlagColour : WatchColour);
					GUI.Label(val4, text2, _labelStyle);
				}
			}
		}

		private void DrawCornerList(bool revealOthers)
		{
			//IL_001d: 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_0022: 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_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: 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_0129: Unknown result type (might be due to invalid IL or missing references)
			//IL_0183: Unknown result type (might be due to invalid IL or missing references)
			//IL_017c: Unknown result type (might be due to invalid IL or missing references)
			//IL_018e: Unknown result type (might be due to invalid IL or missing references)
			Camera activeCamera = GameAccess.ActiveCamera;
			Vector3 val = (((Object)(object)activeCamera != (Object)null) ? ((Component)activeCamera).transform.position : Vector3.zero);
			string text = (revealOthers ? ("AdminHelper  " + _sorted.Count + " watched, " + CountFlagged() + " flagged") : "AdminHelper  admin login required");
			float num = 260f;
			float num2 = 18f;
			Rect val2 = default(Rect);
			((Rect)(ref val2))..ctor(12f, 12f, num, num2 * (float)(_sorted.Count + 1) + 10f);
			GUI.DrawTexture(val2, (Texture)(object)_panelTexture);
			_listStyle.normal.textColor = InfoColour;
			GUI.Label(new Rect(((Rect)(ref val2)).x + 6f, ((Rect)(ref val2)).y + 5f, num - 12f, num2), text, _listStyle);
			Rect val3 = default(Rect);
			for (int i = 0; i < _sorted.Count; i++)
			{
				ScoredPlayer scoredPlayer = _sorted[i];
				float num3 = Horizontal(scoredPlayer.Position - val);
				((Rect)(ref val3))..ctor(((Rect)(ref val2)).x + 6f, ((Rect)(ref val2)).y + 5f + num2 * (float)(i + 1), num - 12f, num2);
				_listStyle.normal.textColor = (scoredPlayer.Flagged ? FlagColour : WatchColour);
				GUI.Label(val3, scoredPlayer.Isolation + "/" + scoredPlayer.Danger + "  " + Mathf.RoundToInt(num3) + "m  " + scoredPlayer.Name, _listStyle);
			}
		}

		private void DrawOwnScore(ScoredPlayer local)
		{
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_011a: Unknown result type (might be due to invalid IL or missing references)
			string text = "ISO: " + local.Isolation + "   DGR: " + local.Danger + "\nmates " + Metres(local.MateDistance) + "   enemy " + Metres(local.EnemyDistance) + " x" + local.EnemyCount + (local.InFormation ? "\nin formation" : "\nout of formation") + "   dwell " + local.DwellSeconds.ToString("0.0") + "s";
			Rect val = default(Rect);
			((Rect)(ref val))..ctor((float)Screen.width - 232f, (float)Screen.height - 76f, 220f, 64f);
			GUI.DrawTexture(val, (Texture)(object)_panelTexture);
			_labelStyle.normal.textColor = (local.Flagged ? FlagColour : InfoColour);
			GUI.Label(val, text, _labelStyle);
		}

		private static string Metres(float distance)
		{
			if (distance >= 9000f)
			{
				return "none";
			}
			return distance.ToString("0.0") + "m";
		}

		private void SortByHeat(List<ScoredPlayer> watched)
		{
			_sorted.Clear();
			_sorted.AddRange(watched);
		}

		private int CountFlagged()
		{
			int num = 0;
			for (int i = 0; i < _sorted.Count; i++)
			{
				if (_sorted[i].Flagged)
				{
					num++;
				}
			}
			return num;
		}

		private void EnsureStyles()
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			//IL_0027: 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_0070: Expected O, but got Unknown
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Expected O, but got Unknown
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Expected O, but got Unknown
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Expected O, but got Unknown
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_panelTexture == (Object)null)
			{
				_panelTexture = new Texture2D(1, 1);
				_panelTexture.SetPixel(0, 0, PanelColour);
				_panelTexture.Apply();
				((Object)_panelTexture).hideFlags = (HideFlags)61;
			}
			if (_labelStyle == null)
			{
				_labelStyle = new GUIStyle(GUI.skin.label);
				_labelStyle.alignment = (TextAnchor)4;
				_labelStyle.fontSize = 13;
				_labelStyle.fontStyle = (FontStyle)1;
				_labelStyle.padding = new RectOffset(6, 6, 3, 3);
				_labelStyle.normal.textColor = FlagColour;
			}
			if (_listStyle == null)
			{
				_listStyle = new GUIStyle(GUI.skin.label);
				_listStyle.alignment = (TextAnchor)3;
				_listStyle.fontSize = 12;
				_listStyle.padding = new RectOffset(0, 0, 0, 0);
				_listStyle.normal.textColor = FlagColour;
			}
		}

		private static float Horizontal(Vector3 delta)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: 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)
			return Mathf.Sqrt(delta.x * delta.x + delta.z * delta.z);
		}
	}
	internal sealed class IsolationTracker
	{
		private sealed class State
		{
			public float Isolation;

			public float Dwell;

			public int LastSeenTick;
		}

		private const float SoloEnemyFloor = 0.5f;

		private const int MaxWatched = 32;

		private readonly Dictionary<int, State> _states = new Dictionary<int, State>();

		private readonly List<PlayerSnapshot> _players = new List<PlayerSnapshot>();

		private readonly Dictionary<FactionCountry, List<PlayerSnapshot>> _byFaction = new Dictionary<FactionCountry, List<PlayerSnapshot>>();

		private readonly List<int> _stale = new List<int>();

		private int _tick;

		public readonly List<ScoredPlayer> Watched = new List<ScoredPlayer>();

		public ScoredPlayer LocalScore;

		public bool HasLocalScore;

		public void Reset()
		{
			_states.Clear();
			_byFaction.Clear();
			Watched.Clear();
			HasLocalScore = false;
		}

		public void Tick(float dt)
		{
			//IL_0076: 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_01ad: Unknown result type (might be due to invalid IL or missing references)
			_tick++;
			Watched.Clear();
			HasLocalScore = false;
			GameAccess.CollectPlayers(_players);
			if (_players.Count == 0)
			{
				DropStaleStates();
				return;
			}
			BucketByFaction();
			int localPlayerId = GameAccess.LocalPlayerId;
			ScoredPlayer scoredPlayer = default(ScoredPlayer);
			for (int i = 0; i < _players.Count; i++)
			{
				PlayerSnapshot self = _players[i];
				List<PlayerSnapshot> list = _byFaction[self.Faction];
				if (list.Count >= 3)
				{
					float num = MateDistance(self, list);
					bool flag = FormationDetector.IsInFormation(self, list);
					float num2 = Curve(num);
					if (flag)
					{
						num2 *= 1f - Mathf.Clamp01(Settings.FormationSuppression.Value);
					}
					State state = ResolveState(self.PlayerId);
					Integrate(state, num2, dt);
					MeasureEnemies(self, out var nearestDistance, out var countInRadius);
					int num3 = Mathf.RoundToInt(state.Isolation * 100f);
					int danger = Mathf.RoundToInt((float)num3 * EnemyThreat(nearestDistance, countInRadius));
					bool flag2 = IsScorable(self);
					if (flag2 && num3 >= Settings.RamboThreshold.Value)
					{
						state.Dwell += dt;
					}
					else
					{
						state.Dwell = Mathf.Max(0f, state.Dwell - dt * Mathf.Max(1f, Settings.RecoverMultiplier.Value));
					}
					scoredPlayer.PlayerId = self.PlayerId;
					scoredPlayer.Name = self.Name;
					scoredPlayer.Position = self.Position;
					scoredPlayer.Isolation = num3;
					scoredPlayer.Danger = danger;
					scoredPlayer.DwellSeconds = state.Dwell;
					scoredPlayer.Flagged = flag2 && state.Dwell >= Settings.RamboHoldSeconds.Value;
					scoredPlayer.MateDistance = num;
					scoredPlayer.EnemyDistance = nearestDistance;
					scoredPlayer.EnemyCount = countInRadius;
					scoredPlayer.InFormation = flag;
					if (flag2 && num3 >= Settings.RingThreshold.Value)
					{
						Watched.Add(scoredPlayer);
					}
					if (self.PlayerId == localPlayerId)
					{
						LocalScore = scoredPlayer;
						HasLocalScore = true;
					}
				}
			}
			SortAndCapWatched();
			DropStaleStates();
		}

		private void SortAndCapWatched()
		{
			Watched.Sort((ScoredPlayer a, ScoredPlayer b) => b.Isolation.CompareTo(a.Isolation));
			if (Watched.Count > 32)
			{
				Watched.RemoveRange(32, Watched.Count - 32);
			}
		}

		private bool IsScorable(PlayerSnapshot self)
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			if (self.IsCavalry && !Settings.ScoreCavalry.Value)
			{
				return false;
			}
			if (self.IsArtillery)
			{
				return false;
			}
			return !Settings.IsExempt(self.Class);
		}

		private static float Curve(float distance)
		{
			float value = Settings.ClusterNearMetres.Value;
			float num = Mathf.Max(value + 1f, Settings.ClusterFarMetres.Value);
			return Mathf.Clamp01((distance - value) / (num - value));
		}

		private float MateDistance(PlayerSnapshot self, List<PlayerSnapshot> friendlies)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: 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_0018: 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_0050: 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_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: 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_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_0124: 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_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: 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_00b3: 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)
			float num = float.MaxValue;
			float num2 = float.MaxValue;
			Vector3 val = Vector3.zero;
			Vector3 val2 = Vector3.zero;
			for (int i = 0; i < friendlies.Count; i++)
			{
				PlayerSnapshot playerSnapshot = friendlies[i];
				if (playerSnapshot.PlayerId != self.PlayerId)
				{
					float num3 = playerSnapshot.Position.x - self.Position.x;
					float num4 = playerSnapshot.Position.z - self.Position.z;
					float num5 = num3 * num3 + num4 * num4;
					if (num5 < num)
					{
						num2 = num;
						val2 = val;
						num = num5;
						val = playerSnapshot.Position;
					}
					else if (num5 < num2)
					{
						num2 = num5;
						val2 = playerSnapshot.Position;
					}
				}
			}
			if (num2 == float.MaxValue)
			{
				return float.MaxValue;
			}
			float num6 = (val.x + val2.x) * 0.5f;
			float num7 = (val.z + val2.z) * 0.5f;
			return Horizontal(self.Position.x - num6, self.Position.z - num7);
		}

		private void MeasureEnemies(PlayerSnapshot self, out float nearestDistance, out int countInRadius)
		{
			//IL_0031: 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_0048: 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_0062: 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)
			float value = Settings.EnemyRadius.Value;
			float num = value * value;
			float num2 = float.MaxValue;
			countInRadius = 0;
			for (int i = 0; i < _players.Count; i++)
			{
				PlayerSnapshot playerSnapshot = _players[i];
				if (playerSnapshot.Faction != self.Faction)
				{
					float num3 = playerSnapshot.Position.x - self.Position.x;
					float num4 = playerSnapshot.Position.z - self.Position.z;
					float num5 = num3 * num3 + num4 * num4;
					if (num5 < num2)
					{
						num2 = num5;
					}
					if (num5 <= num)
					{
						countInRadius++;
					}
				}
			}
			nearestDistance = ((num2 == float.MaxValue) ? float.MaxValue : Mathf.Sqrt(num2));
		}

		private static float EnemyThreat(float nearestDistance, int countInRadius)
		{
			float value = Settings.EnemyRadius.Value;
			if (value <= 0f || nearestDistance > value)
			{
				return 0f;
			}
			float num = Mathf.Clamp01((value - nearestDistance) / value);
			float num2 = Mathf.Clamp01((float)countInRadius / Mathf.Max(1f, (float)Settings.EnemyCrowd.Value));
			return num * (0.5f + 0.5f * num2);
		}

		private static void Integrate(State state, float target, float dt)
		{
			float num = Mathf.Max(0.05f, Settings.RiseSeconds.Value);
			float num2 = 1f / num;
			if (target < state.Isolation)
			{
				num2 *= Mathf.Max(1f, Settings.RecoverMultiplier.Value);
			}
			state.Isolation += (target - state.Isolation) * (1f - Mathf.Exp((0f - num2) * dt));
		}

		private void BucketByFaction()
		{
			//IL_0050: 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_005c: 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)
			foreach (KeyValuePair<FactionCountry, List<PlayerSnapshot>> item in _byFaction)
			{
				item.Value.Clear();
			}
			for (int i = 0; i < _players.Count; i++)
			{
				FactionCountry faction = _players[i].Faction;
				if (!_byFaction.TryGetValue(faction, out var value))
				{
					value = new List<PlayerSnapshot>(150);
					_byFaction[faction] = value;
				}
				value.Add(_players[i]);
			}
		}

		private State ResolveState(int playerId)
		{
			if (!_states.TryGetValue(playerId, out var value))
			{
				value = new State();
				_states[playerId] = value;
			}
			value.LastSeenTick = _tick;
			return value;
		}

		private void DropStaleStates()
		{
			_stale.Clear();
			foreach (KeyValuePair<int, State> state in _states)
			{
				if (_tick - state.Value.LastSeenTick > 60)
				{
					_stale.Add(state.Key);
				}
			}
			for (int i = 0; i < _stale.Count; i++)
			{
				_states.Remove(_stale[i]);
			}
		}

		private static float Horizontal(float dx, float dz)
		{
			return Mathf.Sqrt(dx * dx + dz * dz);
		}
	}
	internal static class Log
	{
		private static readonly ManualLogSource Source = Logger.CreateLogSource("AdminHelper");

		public static void Info(string message)
		{
			Source.LogInfo((object)message);
		}

		public static void Warn(string message)
		{
			Source.LogWarning((object)message);
		}

		public static void Error(string message)
		{
			Source.LogError((object)message);
		}
	}
	internal struct PlayerSnapshot
	{
		public RoundPlayer Player;

		public int PlayerId;

		public string Name;

		public Vector3 Position;

		public FactionCountry Faction;

		public PlayerClass Class;

		public bool IsCavalry;

		public bool IsArtillery;
	}
	internal struct ScoredPlayer
	{
		public int PlayerId;

		public string Name;

		public Vector3 Position;

		public int Isolation;

		public int Danger;

		public float DwellSeconds;

		public bool Flagged;

		public float MateDistance;

		public float EnemyDistance;

		public int EnemyCount;

		public bool InFormation;
	}
	internal sealed class RingRenderer
	{
		private const int Segments = 48;

		private const float Radius = 1.6f;

		private const float GroundOffset = 0.05f;

		private readonly List<LineRenderer> _pool = new List<LineRenderer>();

		private readonly Vector3[] _points = (Vector3[])(object)new Vector3[49];

		private GameObject _root;

		private Shader _shader;

		public void Draw(List<ScoredPlayer> flagged)
		{
			//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_0036: 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_0038: 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_006d: 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)
			EnsureRoot();
			for (int i = 0; i < flagged.Count; i++)
			{
				LineRenderer val = Resolve(i);
				((Component)val).gameObject.SetActive(true);
				Color val2 = ColourFor(flagged[i].Isolation);
				Color startColor = (val.endColor = val2);
				val.startColor = startColor;
				if ((Object)(object)((Renderer)val).sharedMaterial != (Object)null)
				{
					((Renderer)val).sharedMaterial.color = val2;
				}
				BuildCircle(flagged[i].Position);
				val.SetPositions(_points);
			}
			for (int j = flagged.Count; j < _pool.Count; j++)
			{
				if ((Object)(object)_pool[j] != (Object)null)
				{
					((Component)_pool[j]).gameObject.SetActive(false);
				}
			}
		}

		public void HideAll()
		{
			for (int i = 0; i < _pool.Count; i++)
			{
				if ((Object)(object)_pool[i] != (Object)null)
				{
					((Component)_pool[i]).gameObject.SetActive(false);
				}
			}
		}

		public void Destroy()
		{
			_pool.Clear();
			if ((Object)(object)_root != (Object)null)
			{
				Object.Destroy((Object)(object)_root);
			}
			_root = null;
		}

		private void BuildCircle(Vector3 centre)
		{
			//IL_0001: 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_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			float num = centre.y + 0.05f;
			for (int i = 0; i <= 48; i++)
			{
				float num2 = (float)i * (float)Math.PI * 2f / 48f;
				_points[i] = new Vector3(centre.x + Mathf.Cos(num2) * 1.6f, num, centre.z + Mathf.Sin(num2) * 1.6f);
			}
		}

		private static Color ColourFor(int isolation)
		{
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: 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)
			//IL_0061: 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)
			float num = Settings.RingThreshold.Value;
			float num2 = Mathf.Max(num + 1f, (float)Settings.RamboThreshold.Value);
			float num3 = Mathf.Clamp01(((float)isolation - num) / (num2 - num));
			return Color.Lerp(new Color(1f, 0.82f, 0.15f), new Color(1f, 0.25f, 0.1f), num3);
		}

		private void EnsureRoot()
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Expected O, but got Unknown
			if (!((Object)(object)_root != (Object)null))
			{
				_root = new GameObject("AdminHelperRings");
				Object.DontDestroyOnLoad((Object)(object)_root);
				_pool.Clear();
			}
		}

		private LineRenderer Resolve(int index)
		{
			while (_pool.Count <= index)
			{
				_pool.Add(Create());
			}
			LineRenderer val = _pool[index];
			if ((Object)(object)val == (Object)null)
			{
				val = Create();
				_pool[index] = val;
			}
			return val;
		}

		private LineRenderer Create()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Expected O, but got Unknown
			GameObject val = new GameObject("Ring");
			val.transform.SetParent(_root.transform, false);
			LineRenderer val2 = val.AddComponent<LineRenderer>();
			val2.useWorldSpace = true;
			val2.loop = false;
			val2.positionCount = 49;
			float startWidth = (val2.endWidth = 0.14f);
			val2.startWidth = startWidth;
			val2.numCapVertices = 0;
			((Renderer)val2).shadowCastingMode = (ShadowCastingMode)0;
			((Renderer)val2).receiveShadows = false;
			((Renderer)val2).sharedMaterial = new Material(ResolveShader());
			return val2;
		}

		private Shader ResolveShader()
		{
			if ((Object)(object)_shader != (Object)null)
			{
				return _shader;
			}
			_shader = Shader.Find("Universal Render Pipeline/Unlit");
			if ((Object)(object)_shader == (Object)null)
			{
				_shader = Shader.Find("Sprites/Default");
			}
			if ((Object)(object)_shader == (Object)null)
			{
				_shader = Shader.Find("Hidden/Internal-Colored");
			}
			return _shader;
		}
	}
	internal static class Settings
	{
		public static ConfigEntry<bool> Enabled;

		public static ConfigEntry<float> TickHz;

		public static ConfigEntry<bool> RequireAdminLogin;

		public static ConfigEntry<float> ClusterNearMetres;

		public static ConfigEntry<float> ClusterFarMetres;

		public static ConfigEntry<float> RiseSeconds;

		public static ConfigEntry<float> RecoverMultiplier;

		public static ConfigEntry<float> EnemyRadius;

		public static ConfigEntry<int> EnemyCrowd;

		public static ConfigEntry<float> FormationSuppression;

		public static ConfigEntry<float> LineRadius;

		public static ConfigEntry<int> LineMinMates;

		public static ConfigEntry<int> LineMaxMates;

		public static ConfigEntry<float> LineResidual;

		public static ConfigEntry<int> ClusterMinMates;

		public static ConfigEntry<float> ClusterFormationRadius;

		public static ConfigEntry<int> RingThreshold;

		public static ConfigEntry<int> RamboThreshold;

		public static ConfigEntry<float> RamboHoldSeconds;

		public static ConfigEntry<bool> ScoreCavalry;

		public static ConfigEntry<string> ExemptClasses;

		public static ConfigEntry<bool> ShowRings;

		public static ConfigEntry<bool> ShowLabels;

		public static ConfigEntry<bool> ShowCornerList;

		public static ConfigEntry<bool> ShowOwnScore;

		public static ConfigEntry<int> MaxLabels;

		public static ConfigEntry<string> ToggleKey;

		public static ConfigEntry<bool> StartHudVisible;

		private static readonly HashSet<PlayerClass> ExemptSet = new HashSet<PlayerClass>();

		private static string _exemptSource;

		private static string _toggleKeySource;

		private static KeyCode _toggleKey = (KeyCode)287;

		private static ConfigFile _config;

		private static DateTime _stamp;

		private static float _nextCheck;

		public static void Create(ConfigFile config)
		{
			_config = config;
			Enabled = config.Bind<bool>("General", "Enabled", true, "Master switch. Turning this off stops the scorer as well as the HUD.");
			TickHz = config.Bind<float>("General", "TickHz", 5f, "Scoring ticks per second. Higher costs more and buys nothing.");
			RequireAdminLogin = config.Bind<bool>("General", "RequireAdminLogin", true, "Only show other players once the server has authenticated an 'rc login'. Turning this off makes the mod a wallhack.");
			ClusterNearMetres = config.Bind<float>("Isolation", "ClusterNearMetres", 10f, "Distance from the midpoint of your two nearest mates at which isolation starts counting.");
			ClusterFarMetres = config.Bind<float>("Isolation", "ClusterFarMetres", 30f, "Distance at which isolation is fully saturated.");
			RiseSeconds = config.Bind<float>("Scoring", "RiseSeconds", 6f, "Time constant for the score climbing. Larger is slower to flag.");
			RecoverMultiplier = config.Bind<float>("Scoring", "RecoverMultiplier", 3f, "How much faster the score falls than it climbs when a player rejoins.");
			EnemyRadius = config.Bind<float>("Danger", "EnemyRadius", 30f, "How close an enemy has to be before any isolation counts as danger.");
			EnemyCrowd = config.Bind<int>("Danger", "EnemyCrowd", 3, "Enemies inside the radius that count as being fully inside their formation.");
			FormationSuppression = config.Bind<float>("Formation", "FormationSuppression", 0.9f, "Fraction of the raw isolation signal removed while a player is in formation.");
			LineRadius = config.Bind<float>("Formation", "LineRadius", 10f, "Radius searched for formation mates.");
			LineMinMates = config.Bind<int>("Formation", "LineMinMates", 2, "Mates needed before the line fit is attempted.");
			LineMaxMates = config.Bind<int>("Formation", "LineMaxMates", 6, "Most mates fed into the line fit.");
			LineResidual = config.Bind<float>("Formation", "LineResidual", 2f, "Metres of spread either side of the best-fit line still counted as a line.");
			ClusterMinMates = config.Bind<int>("Formation", "ClusterMinMates", 3, "Mates within ClusterFormationRadius that count as a square or skirmisher knot.");
			ClusterFormationRadius = config.Bind<float>("Formation", "ClusterFormationRadius", 8f, "Radius for the tight cluster test.");
			RingThreshold = config.Bind<int>("Flagging", "RingThreshold", 40, "Isolation score at which a marker appears. Tracks the live score, so it clears as a player returns.");
			RamboThreshold = config.Bind<int>("Flagging", "RamboThreshold", 75, "Isolation score at which the dwell timer starts running.");
			RamboHoldSeconds = config.Bind<float>("Flagging", "RamboHoldSeconds", 5f, "Seconds above the threshold before a player is flagged.");
			ScoreCavalry = config.Bind<bool>("Flagging", "ScoreCavalry", false, "Score cavalry too. Off by default since cavalry operating apart is not a rambo.");
			ExemptClasses = config.Bind<string>("Flagging", "ExemptClasses", "", "Comma-separated PlayerClass names that are never flagged, e.g. Surgeon,Sapper.");
			ShowRings = config.Bind<bool>("Display", "ShowRings", true, "Draw a ground ring under each watched player.");
			ShowLabels = config.Bind<bool>("Display", "ShowLabels", true, "Draw the floating name and score label over each watched player.");
			ShowCornerList = config.Bind<bool>("Display", "ShowCornerList", true, "List watched players in the corner with their scores and distance.");
			ShowOwnScore = config.Bind<bool>("Display", "ShowOwnScore", true, "Your own scores plus the raw distances behind them. The fastest way to pick thresholds.");
			MaxLabels = config.Bind<int>("Display", "MaxLabels", 12, "Most floating labels drawn at once, nearest first.");
			ToggleKey = config.Bind<string>("Display", "ToggleKey", "F6", "Key that hides and shows the HUD. Any UnityEngine.KeyCode name.");
			StartHudVisible = config.Bind<bool>("Display", "StartHudVisible", false, "Whether the HUD starts visible when the game launches. After that the toggle sticks until you quit.");
			_stamp = Stamp();
		}

		public static void PollForExternalEdits()
		{
			if (_config != null && !(Time.unscaledTime < _nextCheck))
			{
				_nextCheck = Time.unscaledTime + 1f;
				DateTime dateTime = Stamp();
				if (!(dateTime == _stamp))
				{
					_stamp = dateTime;
					_config.Reload();
				}
			}
		}

		private static DateTime Stamp()
		{
			try
			{
				return File.GetLastWriteTimeUtc(_config.ConfigFilePath);
			}
			catch (Exception)
			{
				return _stamp;
			}
		}

		public static bool IsExempt(PlayerClass playerClass)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			RefreshExemptSet();
			return ExemptSet.Contains(playerClass);
		}

		private static void RefreshExemptSet()
		{
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			string text = ExemptClasses.Value ?? string.Empty;
			if (text == _exemptSource)
			{
				return;
			}
			_exemptSource = text;
			ExemptSet.Clear();
			string[] array = text.Split(',');
			for (int i = 0; i < array.Length; i++)
			{
				string text2 = array[i].Trim();
				if (text2.Length != 0)
				{
					try
					{
						ExemptSet.Add((PlayerClass)Enum.Parse(typeof(PlayerClass), text2, ignoreCase: true));
					}
					catch (Exception)
					{
						Log.Warn("Unknown PlayerClass in ExemptClasses: " + text2);
					}
				}
			}
		}

		public static KeyCode ResolveToggleKey()
		{
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: 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_0024: 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_009d: 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_0057: 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_0072: Unknown result type (might be due to invalid IL or missing references)
			string text = ToggleKey.Value ?? string.Empty;
			if (text == _toggleKeySource)
			{
				return _toggleKey;
			}
			_toggleKeySource = text;
			_toggleKey = (KeyCode)287;
			string text2 = text.Trim();
			if (text2.Length == 0)
			{
				return _toggleKey;
			}
			try
			{
				_toggleKey = (KeyCode)Enum.Parse(typeof(KeyCode), text2, ignoreCase: true);
			}
			catch (Exception)
			{
				Log.Warn("ToggleKey '" + text2 + "' is not a KeyCode name. Falling back to F6.");
			}
			return _toggleKey;
		}
	}
}