using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Text;
using System.Text.RegularExpressions;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using FishNet;
using FishNet.Connection;
using FishNet.Managing;
using FishNet.Managing.Client;
using FishNet.Managing.Logging;
using FishNet.Managing.Server;
using FishNet.Object;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using TMPro;
using UnityEngine;
using UnityEngine.EventSystems;
using UnityEngine.Events;
using UnityEngine.SceneManagement;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("Fishwarden")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("0.15.0.0")]
[assembly: AssemblyInformationalVersion("0.15.0+445db78896d672f01652a0ae886131ba3809b62f")]
[assembly: AssemblyProduct("Fishwarden")]
[assembly: AssemblyTitle("Fishwarden")]
[assembly: AssemblyVersion("0.15.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 Fishwarden
{
	internal static class Actions
	{
		private sealed class Frozen
		{
			public Vector3 At;

			public float Next;
		}

		private static readonly Dictionary<ulong, MuteLines.Reason> _muted = new Dictionary<ulong, MuteLines.Reason>();

		private static readonly Dictionary<ulong, float> _lastHeard = new Dictionary<ulong, float>();

		private static readonly Dictionary<ulong, Frozen> _frozen = new Dictionary<ulong, Frozen>();

		private const float LavaRange = 400f;

		public static int MutedCount => _muted.Count;

		public static int FrozenCount => _frozen.Count;

		public static bool Lockdown { get; private set; }

		public static string Purge(Player keep)
		{
			if (!Plugin.IsHosting)
			{
				return "Only the host can do that.";
			}
			if ((Object)(object)keep == (Object)null)
			{
				return "Nobody by that name.";
			}
			NetworkConnection owner;
			try
			{
				owner = ((NetworkBehaviour)keep).Owner;
			}
			catch
			{
				return "Could not identify them.";
			}
			List<Player> list = new List<Player>();
			try
			{
				foreach (Player player in PlayerManager.Players)
				{
					if (!((Object)(object)player == (Object)null) && !((NetworkBehaviour)player).IsDeinitializing && ((NetworkBehaviour)player).Owner == owner)
					{
						list.Add(player);
					}
				}
			}
			catch
			{
				return "Could not read the lobby.";
			}
			if (list.Count <= 1)
			{
				return keep.SteamName + " only has the one body.";
			}
			int num = 0;
			foreach (Player item in list.Skip(1))
			{
				try
				{
					((NetworkBehaviour)item).NetworkObject.Despawn((DespawnType?)null);
					num++;
				}
				catch (Exception ex)
				{
					Plugin.Log.LogWarning((object)("[Purge] could not despawn a copy: " + ex.Message));
				}
			}
			Plugin.Log.LogWarning((object)$"[Purge] removed {num} copies of {keep.SteamName}");
			return string.Format("Removed {0} spare {1} of {2}.", num, (num == 1) ? "copy" : "copies", keep.SteamName);
		}

		public static string PurgeAll()
		{
			if (!Plugin.IsHosting)
			{
				return "Only the host can do that.";
			}
			Dictionary<NetworkConnection, List<Player>> dictionary = new Dictionary<NetworkConnection, List<Player>>();
			try
			{
				foreach (Player player in PlayerManager.Players)
				{
					if (!((Object)(object)player == (Object)null) && !((NetworkBehaviour)player).IsDeinitializing && !((Object)(object)player == (Object)(object)Player.LocalPlayer) && !(((NetworkBehaviour)player).Owner == (NetworkConnection)null))
					{
						if (!dictionary.TryGetValue(((NetworkBehaviour)player).Owner, out var value))
						{
							value = new List<Player>();
							dictionary[((NetworkBehaviour)player).Owner] = value;
						}
						value.Add(player);
					}
				}
			}
			catch
			{
				return "Could not read the lobby.";
			}
			int num = 0;
			foreach (KeyValuePair<NetworkConnection, List<Player>> item in dictionary.Where((KeyValuePair<NetworkConnection, List<Player>> k) => k.Value.Count > 1))
			{
				foreach (Player item2 in item.Value.Skip(1))
				{
					try
					{
						((NetworkBehaviour)item2).NetworkObject.Despawn((DespawnType?)null);
						num++;
					}
					catch
					{
					}
				}
			}
			if (num != 0)
			{
				return $"Removed {num} duplicate bodies.";
			}
			return "No duplicates in the lobby.";
		}

		public static bool IsMuted(ulong id)
		{
			return _muted.ContainsKey(id);
		}

		public static MuteLines.Reason ReasonFor(ulong id)
		{
			if (!_muted.TryGetValue(id, out var value))
			{
				return MuteLines.Reason.General;
			}
			return value;
		}

		public static string CycleReason(Player p)
		{
			if ((Object)(object)p == (Object)null)
			{
				return "Nobody by that name.";
			}
			MuteLines.Reason reason = ReasonFor(p.SteamID);
			MuteLines.Reason reason2 = ((reason != MuteLines.Reason.Shouting) ? (reason + 1) : MuteLines.Reason.General);
			if (_muted.ContainsKey(p.SteamID))
			{
				_muted[p.SteamID] = reason2;
			}
			return p.SteamName + " muted for: " + MuteLines.Name(reason2);
		}

		public static string ToggleMute(Player p)
		{
			return ToggleMute(p, MuteLines.Reason.General);
		}

		public static string ToggleMute(Player p, MuteLines.Reason reason)
		{
			if ((Object)(object)p == (Object)null)
			{
				return "Nobody by that name.";
			}
			if (_muted.Remove(p.SteamID))
			{
				return p.SteamName + " can talk again.";
			}
			_muted[p.SteamID] = reason;
			return p.SteamName + " has been muted for " + MuteLines.Name(reason) + ".";
		}

		public static bool VoiceFrame(NetworkConnection conn)
		{
			if (_muted.Count == 0 || !Plugin.IsHosting)
			{
				return true;
			}
			Player val = Sender.PlayerFor(conn);
			if ((Object)(object)val == (Object)null)
			{
				return true;
			}
			ulong steamID;
			try
			{
				steamID = val.SteamID;
			}
			catch
			{
				return true;
			}
			if (!_muted.ContainsKey(steamID))
			{
				return true;
			}
			float realtimeSinceStartup = Time.realtimeSinceStartup;
			if (!_lastHeard.TryGetValue(steamID, out var value) || realtimeSinceStartup - value > Plugin.MuteNoticeInterval.Value)
			{
				_lastHeard[steamID] = realtimeSinceStartup;
				if (Plugin.MuteAnnounce.Value)
				{
					Chat.AsPlayer(val, MuteLines.For(ReasonFor(steamID), val.SteamName));
				}
			}
			return false;
		}

		public static bool ShouldMute(NetworkConnection conn)
		{
			if (_muted.Count == 0)
			{
				return false;
			}
			Player val = Sender.PlayerFor(conn);
			if ((Object)(object)val == (Object)null)
			{
				return false;
			}
			try
			{
				return _muted.ContainsKey(val.SteamID);
			}
			catch
			{
				return false;
			}
		}

		public static bool IsFrozen(ulong id)
		{
			return _frozen.ContainsKey(id);
		}

		public static string ToggleFreeze(Player p)
		{
			//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)
			if ((Object)(object)p == (Object)null)
			{
				return "Nobody by that name.";
			}
			if (!Plugin.IsHosting)
			{
				return "Only the host can do that.";
			}
			if (_frozen.Remove(p.SteamID))
			{
				return p.SteamName + " can move again.";
			}
			try
			{
				_frozen[p.SteamID] = new Frozen
				{
					At = Body.Of(p)
				};
			}
			catch
			{
				return "Could not read where they are.";
			}
			return p.SteamName + " is frozen where they stand.";
		}

		public static void TickFreeze()
		{
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			if (_frozen.Count == 0 || !Plugin.IsHosting)
			{
				return;
			}
			float realtimeSinceStartup = Time.realtimeSinceStartup;
			try
			{
				foreach (Player player in PlayerManager.Players)
				{
					if (!((Object)(object)player == (Object)null) && !((Object)(object)player == (Object)(object)Player.LocalPlayer) && _frozen.TryGetValue(player.SteamID, out var value) && !(realtimeSinceStartup < value.Next))
					{
						value.Next = realtimeSinceStartup + Plugin.FreezeInterval.Value;
						try
						{
							Server.Instance.TeleportPlayer(player, value.At, 0f);
						}
						catch
						{
						}
					}
				}
			}
			catch
			{
			}
		}

		public static string ToggleLockdown()
		{
			if (!Plugin.IsHosting)
			{
				return "Only the host can do that.";
			}
			Lockdown = !Lockdown;
			if (!Lockdown)
			{
				return "Lockdown off - the lobby is open again.";
			}
			return "Lockdown ON - anyone not on the crew list is removed as they arrive.";
		}

		public static void EnforceLockdown()
		{
			if (!Lockdown || !Plugin.IsHosting)
			{
				return;
			}
			try
			{
				foreach (Player player in PlayerManager.Players)
				{
					if ((Object)(object)player == (Object)null || (Object)(object)player == (Object)(object)Player.LocalPlayer)
					{
						continue;
					}
					ulong steamID;
					try
					{
						steamID = player.SteamID;
					}
					catch
					{
						continue;
					}
					if (!Crew.Has(steamID))
					{
						try
						{
							((NetworkBehaviour)player).Owner.Kick((KickReason)0, (LoggingType)3, "This lobby is locked down. Ask the host for an invite.");
							Plugin.Log.LogWarning((object)("[Lockdown] refused " + player.SteamName));
						}
						catch
						{
						}
					}
				}
			}
			catch
			{
			}
		}

		public static string Strip(Player p)
		{
			//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)
			if (!Plugin.IsHosting)
			{
				return "Only the host can do that.";
			}
			if ((Object)(object)p == (Object)null)
			{
				return "Nobody by that name.";
			}
			try
			{
				Server.Instance.DropAllItems(p, Body.Of(p), Quaternion.identity);
				return p.SteamName + " has been relieved of everything they were carrying.";
			}
			catch (Exception ex)
			{
				return "Could not: " + ex.Message;
			}
		}

		public static void Release(ulong id)
		{
			_muted.Remove(id);
			_frozen.Remove(id);
		}

		public static string Status()
		{
			List<string> list = new List<string>();
			if (Lockdown)
			{
				list.Add("LOCKDOWN");
			}
			if (_muted.Count > 0)
			{
				list.Add($"{_muted.Count} muted");
			}
			if (_frozen.Count > 0)
			{
				list.Add($"{_frozen.Count} frozen");
			}
			if (list.Count != 0)
			{
				return string.Join(", ", list);
			}
			return "";
		}

		public static string SendBossAway()
		{
			if (!Plugin.IsHosting)
			{
				return "Despawning is server side - host or play solo.";
			}
			try
			{
				if (!Object.op_Implicit((Object)(object)BossManager.Boss))
				{
					return "There is no boss up.";
				}
			}
			catch
			{
				return "The boss manager is not up yet.";
			}
			try
			{
				string text = "The boss";
				try
				{
					text = ((Object)BossManager.Boss).name.Replace("(Clone)", "").Trim();
				}
				catch
				{
				}
				MethodInfo methodInfo = AccessTools.Method(typeof(BossManager), "KillBoss", (Type[])null, (Type[])null);
				if (methodInfo != null)
				{
					object obj3 = (methodInfo.IsStatic ? null : Object.FindAnyObjectByType<BossManager>());
					if (!methodInfo.IsStatic && obj3 == null)
					{
						return "No boss manager in the scene.";
					}
					ParameterInfo[] parameters = methodInfo.GetParameters();
					methodInfo.Invoke(obj3, (parameters.Length == 0) ? null : new object[parameters.Length]);
					return text + " sent away.";
				}
				Creature boss = BossManager.Boss;
				if ((Object)(object)boss != (Object)null)
				{
					GameObject gameObject = ((Component)boss).gameObject;
					try
					{
						((NetworkBehaviour)Server.Instance).Despawn(gameObject, (DespawnType?)null);
					}
					catch
					{
						Object.Destroy((Object)(object)gameObject);
					}
					Plugin.Log.LogInfo((object)("[Actions] no KillBoss on BossManager - despawned " + text + " directly."));
					return text + " removed. This build has no KillBoss, so the fight state may need a moment to catch up.";
				}
				return "No boss to send away.";
			}
			catch (Exception ex)
			{
				return "Could not send it away: " + ex.Message;
			}
		}
	}
	internal static class Aim
	{
		private sealed class Shooter
		{
			public int Shots;

			public int Hits;

			public float LastShot = -1f;

			public float LastFinding = -999f;

			public int Blocked;
		}

		private static readonly Dictionary<ulong, Shooter> _shooters = new Dictionary<ulong, Shooter>();

		private static Shooter For(NetworkConnection conn)
		{
			ulong key = Sender.KeyOf(conn);
			if (!_shooters.TryGetValue(key, out var value))
			{
				value = new Shooter();
				_shooters[key] = value;
			}
			return value;
		}

		public static void NoteShot(NetworkConnection conn)
		{
			Shooter shooter = For(conn);
			shooter.Shots++;
			shooter.LastShot = Time.realtimeSinceStartup;
		}

		public static float SinceLastShot(NetworkConnection conn)
		{
			Shooter shooter = For(conn);
			if (!(shooter.LastShot < 0f))
			{
				return Time.realtimeSinceStartup - shooter.LastShot;
			}
			return -1f;
		}

		public static Verdict NoteHit(NetworkConnection conn, Player shooter, Vector3 hitPoint)
		{
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			if (!Plugin.WatchAim.Value)
			{
				return Verdict.Clean;
			}
			Shooter shooter2 = For(conn);
			shooter2.Hits++;
			float realtimeSinceStartup = Time.realtimeSinceStartup;
			if (Plugin.CheckLineOfSight.Value && Blocked(shooter, hitPoint))
			{
				shooter2.Blocked++;
				if (shooter2.Blocked >= Plugin.BlockedShotsForFinding.Value && Ready(shooter2, realtimeSinceStartup))
				{
					shooter2.LastFinding = realtimeSinceStartup;
					int blocked = shooter2.Blocked;
					shooter2.Blocked = 0;
					return Verdict.Strong("shot-through-wall", $"{blocked} hits landed with solid geometry in the way");
				}
				return Verdict.Clean;
			}
			if (shooter2.Shots >= Plugin.AccuracySampleSize.Value)
			{
				float num = (float)shooter2.Hits / (float)shooter2.Shots;
				int shots = shooter2.Shots;
				shooter2.Shots = 0;
				shooter2.Hits = 0;
				if (num >= Plugin.SuspiciousAccuracy.Value && Ready(shooter2, realtimeSinceStartup))
				{
					shooter2.LastFinding = realtimeSinceStartup;
					return Verdict.Contextual("perfect-accuracy", $"{num * 100f:0}% of {shots} shots connected");
				}
			}
			return Verdict.Clean;
		}

		private static bool Blocked(Player shooter, Vector3 hitPoint)
		{
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: 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_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: 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_0043: 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)
			//IL_006f: 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_0078: 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_0082: 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_00a1: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)shooter == (Object)null)
			{
				return false;
			}
			try
			{
				Vector3 val = (((Object)(object)shooter.CamObject != (Object)null) ? shooter.CamObject.position : (Body.Of(shooter) + Vector3.up * 1.5f));
				Vector3 val2 = hitPoint - val;
				float magnitude = ((Vector3)(ref val2)).magnitude;
				if (magnitude < Plugin.LineOfSightMinDistance.Value)
				{
					return false;
				}
				float value = Plugin.LineOfSightPadding.Value;
				Vector3 val3 = val + ((Vector3)(ref val2)).normalized * value;
				float num = magnitude - value * 2f;
				if (num <= 0f)
				{
					return false;
				}
				return Physics.Raycast(val3, ((Vector3)(ref val2)).normalized, num, Plugin.LineOfSightMask.Value, (QueryTriggerInteraction)1);
			}
			catch
			{
				return false;
			}
		}

		private static bool Ready(Shooter s, float now)
		{
			return now - s.LastFinding >= Plugin.MovementFindingCooldown.Value;
		}

		public static void Reset()
		{
			_shooters.Clear();
		}
	}
	internal static class AutoTroll
	{
		public enum Trigger
		{
			Off,
			AnyProven,
			AfterStrikes,
			ChosenRules
		}

		private static readonly HashSet<ulong> _armedBy = new HashSet<ulong>();

		public static int AutoArmedCount => _armedBy.Count;

		public static IEnumerable<string> Chosen => from x in (Plugin.AutoTrollRules.Value ?? "").Split(',')
			select x.Trim() into x
			where x.Length > 0
			select x;

		public static Trigger Mode
		{
			get
			{
				if (!Enum.TryParse<Trigger>(Plugin.AutoTrollMode.Value, ignoreCase: true, out var result))
				{
					return Trigger.Off;
				}
				return result;
			}
		}

		public static bool WasAutomatic(ulong id)
		{
			return _armedBy.Contains(id);
		}

		public static bool Arms(string rule)
		{
			if (!string.IsNullOrWhiteSpace(rule))
			{
				return Chosen.Contains<string>(rule, StringComparer.OrdinalIgnoreCase);
			}
			return false;
		}

		public static string ToggleRule(string rule)
		{
			if (string.IsNullOrWhiteSpace(rule))
			{
				return "No rule named.";
			}
			List<string> list = Chosen.ToList();
			bool num = list.RemoveAll((string r) => string.Equals(r, rule, StringComparison.OrdinalIgnoreCase)) > 0;
			if (!num)
			{
				list.Add(rule);
			}
			Plugin.AutoTrollRules.Value = string.Join(",", list.ToArray());
			if (!num)
			{
				return rule + " now arms troll mode on its own.";
			}
			return rule + " no longer arms troll mode.";
		}

		public static void SetMode(Trigger t)
		{
			Plugin.AutoTrollMode.Value = t.ToString();
			Plugin.Log.LogInfo((object)("[AutoTroll] " + Describe(t)));
		}

		public static string Describe(Trigger t)
		{
			return t switch
			{
				Trigger.Off => "off - troll mode is manual only", 
				Trigger.AnyProven => "arms the moment anything proven lands", 
				Trigger.AfterStrikes => $"arms after {Plugin.AutoTrollStrikes.Value} strikes", 
				Trigger.ChosenRules => "arms only for the rules you chose", 
				_ => t.ToString(), 
			};
		}

		public static string Summary()
		{
			string text = "Auto-troll: " + Describe(Mode);
			if (Mode == Trigger.ChosenRules)
			{
				List<string> list = Chosen.ToList();
				text += ((list.Count == 0) ? "  (no rules chosen yet)" : ("  [" + string.Join(", ", list) + "]"));
			}
			return text;
		}

		public static void Consider(NetworkConnection conn, ulong key, string who, Verdict v)
		{
			Trigger mode = Mode;
			if (mode == Trigger.Off || !Plugin.IsHosting || Troll.Is(key) || Sender.IsTrusted(conn) || v.Confidence == Confidence.Contextual || (mode != Trigger.ChosenRules && !Response.Trolls(v.Rule)))
			{
				return;
			}
			bool flag = false;
			switch (mode)
			{
			case Trigger.AnyProven:
				flag = v.Confidence == Confidence.Certain;
				break;
			case Trigger.AfterStrikes:
				flag = Logbook.StrikesFor(conn) >= Plugin.AutoTrollStrikes.Value;
				break;
			case Trigger.ChosenRules:
				flag = v.Rule != null && Chosen.Any((string r) => string.Equals(r, v.Rule, StringComparison.OrdinalIgnoreCase));
				break;
			}
			if (flag)
			{
				Player val = Sender.PlayerFor(conn);
				if (!((Object)(object)val == (Object)null))
				{
					_armedBy.Add(key);
					Plugin.Log.LogWarning((object)("[AutoTroll] armed on " + who + " after '" + v.Rule + "'"));
					Troll.Toggle(val);
				}
			}
		}

		public static void Forget(ulong key)
		{
			_armedBy.Remove(key);
		}

		public static void Reset()
		{
			_armedBy.Clear();
		}
	}
	internal static class Bans
	{
		internal sealed class Record
		{
			public ulong SteamId;

			public string Name;

			public string Reason;

			public DateTime When;

			public string Line => $"{SteamId}|{When:yyyy-MM-dd HH:mm:ss}|{Name}|{Reason}";

			public static Record Parse(string line)
			{
				string[] array = line.Split('|');
				if (array.Length < 4)
				{
					return null;
				}
				if (!ulong.TryParse(array[0], out var result))
				{
					return null;
				}
				DateTime.TryParse(array[1], CultureInfo.InvariantCulture, DateTimeStyles.None, out var result2);
				return new Record
				{
					SteamId = result,
					When = result2,
					Name = array[2],
					Reason = string.Join("|", array.Skip(3))
				};
			}
		}

		private static readonly Dictionary<ulong, Record> _banned = new Dictionary<ulong, Record>();

		private static string File_ => Path.Combine(Logbook.Folder, "trophy-wall.txt");

		public static int Count => _banned.Count;

		public static IEnumerable<Record> All => _banned.Values;

		public static void Load()
		{
			_banned.Clear();
			try
			{
				if (!File.Exists(File_))
				{
					return;
				}
				string[] array = File.ReadAllLines(File_);
				foreach (string text in array)
				{
					if (!string.IsNullOrWhiteSpace(text) && !text.StartsWith("#"))
					{
						Record record = Record.Parse(text.Trim());
						if (record != null)
						{
							_banned[record.SteamId] = record;
						}
					}
				}
				Plugin.Log.LogInfo((object)$"[TrophyWall] {_banned.Count} on the wall.");
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("[TrophyWall] could not read the list: " + ex.Message));
			}
		}

		private static void Save()
		{
			try
			{
				Directory.CreateDirectory(Logbook.Folder);
				List<string> list = new List<string> { "# Fishwarden trophy wall - one per line: steamid|when|name|reason", "# Delete a line to let that player back in." };
				list.AddRange(_banned.Values.Select((Record r) => r.Line));
				File.WriteAllLines(File_, list);
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("[TrophyWall] could not save: " + ex.Message));
			}
		}

		public static bool IsBanned(ulong steamId)
		{
			return _banned.ContainsKey(steamId);
		}

		public static bool IsBanned(NetworkConnection conn)
		{
			Player val = Sender.PlayerFor(conn);
			if ((Object)(object)val == (Object)null)
			{
				return false;
			}
			try
			{
				return IsBanned(val.SteamID);
			}
			catch
			{
				return false;
			}
		}

		public static void Add(ulong steamId, string name, string reason)
		{
			if (steamId != 0L)
			{
				_banned[steamId] = new Record
				{
					SteamId = steamId,
					Name = name,
					Reason = reason,
					When = DateTime.Now
				};
				Save();
				Plugin.Log.LogWarning((object)$"[TrophyWall] mounted {name} ({steamId}): {reason}");
			}
		}

		public static bool Remove(ulong steamId)
		{
			if (!_banned.Remove(steamId))
			{
				return false;
			}
			Save();
			return true;
		}

		public static Record Find(string nameFragment)
		{
			string q = (nameFragment ?? "").ToLowerInvariant();
			return _banned.Values.FirstOrDefault((Record r) => (r.Name ?? "").ToLowerInvariant().Contains(q));
		}

		public static void Sweep()
		{
			if (!Plugin.IsHosting || !Plugin.EnforceBans.Value)
			{
				return;
			}
			try
			{
				foreach (Player player in PlayerManager.Players)
				{
					if ((Object)(object)player == (Object)null || (Object)(object)player == (Object)(object)Player.LocalPlayer)
					{
						continue;
					}
					ulong steamID;
					try
					{
						steamID = player.SteamID;
					}
					catch
					{
						continue;
					}
					if (steamID != 0L && IsBanned(steamID))
					{
						Record record = _banned[steamID];
						Guard.Announce("[Fishwarden] " + player.SteamName + " is on the trophy wall (" + record.Reason + "). Gone fishing.");
						try
						{
							((NetworkBehaviour)player).Owner.Kick((KickReason)0, (LoggingType)3, "Fishwarden: banned - " + record.Reason);
							Plugin.Log.LogWarning((object)("[TrophyWall] refused " + player.SteamName + " on rejoin."));
						}
						catch (Exception ex)
						{
							Plugin.Log.LogError((object)("[TrophyWall] kick failed: " + ex.Message));
						}
					}
				}
			}
			catch
			{
			}
		}
	}
	internal static class Body
	{
		public static string Survey()
		{
			//IL_0084: 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_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: 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)
			int num = 0;
			Plugin.Log.LogInfo((object)"[Body] who is where - lowercase transform | Transform | rigidbody");
			try
			{
				foreach (Player player in PlayerManager.Players)
				{
					if ((Object)(object)player == (Object)null)
					{
						continue;
					}
					string text = "?";
					string text2 = "?";
					string text3 = "?";
					Vector3 val;
					try
					{
						val = ((Component)player).transform.position;
						text = ((Vector3)(ref val)).ToString("0.0");
					}
					catch
					{
					}
					try
					{
						object obj2;
						if (!((Object)(object)player.Transform != (Object)null))
						{
							obj2 = "null";
						}
						else
						{
							val = player.Transform.position;
							obj2 = ((Vector3)(ref val)).ToString("0.0");
						}
						text2 = (string)obj2;
					}
					catch
					{
					}
					try
					{
						object obj4;
						if (!((Object)(object)player.Rigidbody != (Object)null))
						{
							obj4 = "null";
						}
						else
						{
							val = player.Rigidbody.worldCenterOfMass;
							obj4 = ((Vector3)(ref val)).ToString("0.0");
						}
						text3 = (string)obj4;
					}
					catch
					{
					}
					string text4 = "?";
					try
					{
						text4 = player.SteamName;
					}
					catch
					{
					}
					Plugin.Log.LogInfo((object)("[Body]   " + (((Object)(object)player == (Object)(object)Player.LocalPlayer) ? "* " : "  ") + text4 + "  " + text + " | " + text2 + " | " + text3));
					num++;
				}
			}
			catch (Exception ex)
			{
				return "Could not read the lobby: " + ex.Message;
			}
			Plugin.Log.LogInfo((object)"[Body] (* is you. If the first column is 0,0,0 and the others are not, everything reading the first column is wrong.)");
			return num + " player(s) written to the log - compare the three columns.";
		}

		public static bool Sane(Vector3 v)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: 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_0041: 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_0060: 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)
			if (!float.IsNaN(v.x) && !float.IsNaN(v.y) && !float.IsNaN(v.z) && !float.IsInfinity(v.x) && !float.IsInfinity(v.y) && !float.IsInfinity(v.z) && Mathf.Abs(v.x) < 1000000f && Mathf.Abs(v.y) < 1000000f)
			{
				return Mathf.Abs(v.z) < 1000000f;
			}
			return false;
		}

		public static Vector3 Of(Player p)
		{
			//IL_0063: 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_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: 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_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_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)
			if ((Object)(object)p == (Object)null)
			{
				return Vector3.zero;
			}
			try
			{
				if ((Object)(object)p.Rigidbody != (Object)null)
				{
					return p.Rigidbody.worldCenterOfMass;
				}
			}
			catch
			{
			}
			try
			{
				if ((Object)(object)p.Transform != (Object)null)
				{
					return p.Transform.position;
				}
			}
			catch
			{
			}
			try
			{
				return ((Component)p).transform.position;
			}
			catch
			{
				return Vector3.zero;
			}
		}

		public static Vector3 Facing(Player p)
		{
			//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_0050: 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_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)
			Vector3 forward = Vector3.forward;
			try
			{
				if ((Object)(object)p != (Object)null && (Object)(object)p.Transform != (Object)null)
				{
					forward = p.Transform.forward;
				}
			}
			catch
			{
			}
			forward.y = 0f;
			if (!(((Vector3)(ref forward)).sqrMagnitude < 0.01f))
			{
				return ((Vector3)(ref forward)).normalized;
			}
			return Vector3.forward;
		}

		public static Vector3 InFrontOf(Player p, float metres = 2f)
		{
			//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_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_0017: 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)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			return Of(p) + Facing(p) * metres + Vector3.up * 0.5f;
		}
	}
	internal static class Cases
	{
		internal sealed class Case
		{
			public int Id;

			public ulong Key;

			public string Name;

			public int Strikes;

			public DateTime Opened;

			public float OpenedAt;

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

			public bool Proven;

			public string Shot;
		}

		private static readonly List<Case> _open = new List<Case>();

		private static readonly Dictionary<string, int> _dismissedRules = new Dictionary<string, int>();

		private static int _nextId = 1;

		public static int PendingCount => _open.Count;

		public static IReadOnlyList<Case> Open => _open;

		public static void OpenCase(NetworkConnection conn, int strikes)
		{
			ulong key = Sender.KeyOf(conn);
			if (_open.Any((Case c) => c.Key == key))
			{
				Refresh(key, strikes);
				return;
			}
			List<Entry> source = Logbook.Entries.Where((Entry e) => e.Key == key).ToList();
			Case obj = new Case
			{
				Id = _nextId++,
				Key = key,
				Name = Sender.NameOf(conn),
				Strikes = strikes,
				Opened = DateTime.Now,
				OpenedAt = Time.realtimeSinceStartup,
				Proven = source.Any((Entry e) => e.Verdict.Confidence == Confidence.Certain),
				Shot = source.LastOrDefault((Entry e) => e.Shot != null)?.Shot,
				Rules = (from e in source
					select e.Verdict.Rule into r
					where r != null
					select r).Distinct().ToList()
			};
			_open.Add(obj);
			Plugin.Log.LogWarning((object)($"[Case #{obj.Id}] {obj.Name} - {strikes} strikes, " + (obj.Proven ? "PROVEN" : "unproven") + ", rules: " + string.Join(", ", obj.Rules)));
			Tell($"Case #{obj.Id}: {obj.Name} - {strikes} strikes" + (obj.Proven ? " (proven)" : " (heuristics only)"));
			Tell("  " + string.Join(", ", obj.Rules));
			Tell($"  /accept {obj.Id} to remove   /dismiss {obj.Id} to clear");
		}

		private static void Refresh(ulong key, int strikes)
		{
			Case obj = _open.FirstOrDefault((Case x) => x.Key == key);
			if (obj != null)
			{
				obj.Strikes = strikes;
				List<Entry> source = Logbook.Entries.Where((Entry e) => e.Key == key).ToList();
				obj.Proven = source.Any((Entry e) => e.Verdict.Confidence == Confidence.Certain);
				obj.Rules = (from e in source
					select e.Verdict.Rule into r
					where r != null
					select r).Distinct().ToList();
			}
		}

		public static void Tick()
		{
			if (_open.Count == 0)
			{
				return;
			}
			float num = Plugin.CaseExpiryMinutes.Value * 60f;
			if (num <= 0f)
			{
				return;
			}
			float realtimeSinceStartup = Time.realtimeSinceStartup;
			for (int num2 = _open.Count - 1; num2 >= 0; num2--)
			{
				if (!(realtimeSinceStartup - _open[num2].OpenedAt < num))
				{
					Plugin.Log.LogInfo((object)$"[Case #{_open[num2].Id}] expired unreviewed ({_open[num2].Name}).");
					_open.RemoveAt(num2);
				}
			}
		}

		public static string Accept(int id)
		{
			Case obj = _open.FirstOrDefault((Case x) => x.Id == id);
			if (obj == null)
			{
				return $"No open case #{id}.";
			}
			_open.Remove(obj);
			NetworkConnection val = FindConn(obj.Key);
			if (val == (NetworkConnection)null)
			{
				if (Plugin.EnforceBans.Value)
				{
					Bans.Add(obj.Key, obj.Name, string.Format("case #{0}: {1}", obj.Id, string.Join(", ", obj.Rules)));
					return obj.Name + " has already left - added to the trophy wall so they cannot come back.";
				}
				return obj.Name + " has already left.";
			}
			Guard.RemoveNow(val, obj.Strikes, string.Format("case #{0}: {1}", obj.Id, string.Join(", ", obj.Rules)));
			return $"Case #{obj.Id} accepted - {obj.Name} removed.";
		}

		public static string Dismiss(int id)
		{
			Case obj = _open.FirstOrDefault((Case x) => x.Id == id);
			if (obj == null)
			{
				return $"No open case #{id}.";
			}
			_open.Remove(obj);
			Logbook.Pardon(obj.Key);
			Rollback.Clear(obj.Key);
			Safety.Forget(obj.Key);
			foreach (string rule in obj.Rules)
			{
				_dismissedRules.TryGetValue(rule, out var value);
				_dismissedRules[rule] = value + 1;
				if (value + 1 >= Plugin.NoisyRuleThreshold.Value)
				{
					Plugin.Log.LogWarning((object)($"[Bycatch] rule '{rule}' has now been dismissed {value + 1} times. " + "It is probably firing on normal play - worth turning off or loosening."));
				}
			}
			return $"Case #{obj.Id} dismissed - {obj.Name} cleared, strikes wiped.";
		}

		public static string AcceptAll()
		{
			if (_open.Count == 0)
			{
				return "No open cases.";
			}
			List<int> source = _open.Select((Case c) => c.Id).ToList();
			return string.Join("  ", source.Select(Accept));
		}

		public static string DismissAll()
		{
			if (_open.Count == 0)
			{
				return "No open cases.";
			}
			List<int> source = _open.Select((Case c) => c.Id).ToList();
			return string.Join("  ", source.Select(Dismiss));
		}

		public static string List()
		{
			if (_open.Count == 0)
			{
				return "No cases waiting.";
			}
			List<string> list = new List<string> { $"{_open.Count} case(s) waiting:" };
			foreach (Case item in _open)
			{
				list.Add($"  #{item.Id}  {item.Name}  {item.Strikes} strikes  " + (item.Proven ? "PROVEN" : "heuristics only") + "  [" + string.Join(", ", item.Rules) + "]" + ((item.Shot != null) ? ("  shot: " + item.Shot) : ""));
			}
			list.Add("  /accept <n> | /dismiss <n> | /accept all | /dismiss all");
			return string.Join("\n", list);
		}

		public static IEnumerable<string> NoisyRules()
		{
			return from kv in _dismissedRules
				where kv.Value >= Plugin.NoisyRuleThreshold.Value && Rules.Enabled(kv.Key)
				select kv.Key;
		}

		public static string Noisy()
		{
			List<KeyValuePair<string, int>> list = _dismissedRules.Where((KeyValuePair<string, int> kv) => kv.Value >= Plugin.NoisyRuleThreshold.Value).ToList();
			if (list.Count == 0)
			{
				return null;
			}
			return "Noisy rules: " + string.Join(", ", list.Select((KeyValuePair<string, int> kv) => $"{kv.Key} (x{kv.Value})"));
		}

		private static NetworkConnection FindConn(ulong key)
		{
			try
			{
				foreach (Player player in PlayerManager.Players)
				{
					if (!((Object)(object)player == (Object)null) && !((Object)(object)player == (Object)(object)Player.LocalPlayer) && player.SteamID == key)
					{
						return ((NetworkBehaviour)player).Owner;
					}
				}
			}
			catch
			{
			}
			return null;
		}

		private static void Tell(string msg)
		{
			Chat.Ask(msg);
		}

		public static void Reset()
		{
			_open.Clear();
			_dismissedRules.Clear();
			_nextId = 1;
		}
	}
	internal static class Catalogue
	{
		private static readonly HashSet<byte> _forSale = new HashSet<byte>();

		private static float _builtAt = -999f;

		private static int _stands;

		private static bool _usable;

		private static float _nextMoan;

		private static string _shelf = "";

		public static bool Usable => _usable;

		public static int Stands => _stands;

		public static int Count => _forSale.Count;

		public static IEnumerable<byte> Ids => _forSale.OrderBy((byte x) => x);

		public static string Shelf
		{
			get
			{
				Refresh();
				return _shelf;
			}
		}

		public static bool Sells(byte id)
		{
			Refresh();
			if (!_usable)
			{
				Blind();
				return true;
			}
			return _forSale.Contains(id);
		}

		public static void Watch()
		{
			Refresh();
			if (!_usable)
			{
				Blind();
			}
		}

		private static void Blind()
		{
			float realtimeSinceStartup = Time.realtimeSinceStartup;
			if (!(realtimeSinceStartup < _nextMoan))
			{
				_nextMoan = realtimeSinceStartup + 30f;
				Plugin.Log.LogWarning((object)"[Catalogue] no shop stands found, so 'not-for-sale' cannot run and every purchase is being allowed on affordability alone. This is the hole creatures come through.");
			}
		}

		private static void Refresh()
		{
			if (Time.realtimeSinceStartup - _builtAt < Plugin.CatalogueRefresh.Value)
			{
				return;
			}
			_builtAt = Time.realtimeSinceStartup;
			try
			{
				ItemPurchasable[] array = Resources.FindObjectsOfTypeAll<ItemPurchasable>();
				if (array == null || array.Length == 0)
				{
					if (_forSale.Count == 0)
					{
						_usable = false;
					}
					return;
				}
				HashSet<byte> hashSet = new HashSet<byte>();
				SortedSet<string> sortedSet = new SortedSet<string>(StringComparer.OrdinalIgnoreCase);
				ItemPurchasable[] array2 = array;
				foreach (ItemPurchasable val in array2)
				{
					if ((Object)(object)val == (Object)null)
					{
						continue;
					}
					try
					{
						object value = Traverse.Create((object)val).Field("_itemToPurchase").GetValue();
						Item val2 = (Item)((value is Item) ? value : null);
						if ((Object)(object)val2 == (Object)null)
						{
							continue;
						}
						hashSet.Add(val2.ID);
						try
						{
							if (!string.IsNullOrEmpty(((Object)val2).name))
							{
								sortedSet.Add(((Object)val2).name);
							}
						}
						catch
						{
						}
					}
					catch
					{
					}
				}
				if (hashSet.Count == 0)
				{
					if (_forSale.Count == 0)
					{
						_usable = false;
					}
					return;
				}
				bool usable = _usable;
				_stands = array.Length;
				_forSale.Clear();
				foreach (byte item in hashSet)
				{
					_forSale.Add(item);
				}
				_usable = true;
				_shelf = string.Join(", ", sortedSet.ToArray());
				if (!usable)
				{
					Plugin.Log.LogInfo((object)($"[Catalogue] {_stands} shop stand(s) selling " + $"{_forSale.Count} item(s) - purchases of anything else " + "are now proven."));
					if (_shelf.Length > 0)
					{
						Plugin.Log.LogInfo((object)("[Catalogue] on the shelves: " + _shelf));
					}
				}
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("[Catalogue] could not read the shop stands: " + ex.Message));
				if (_forSale.Count == 0)
				{
					_usable = false;
				}
			}
		}

		public static string Summary()
		{
			Refresh();
			if (!_usable)
			{
				return "Shop catalogue unavailable - purchases are not being checked against it.";
			}
			return $"{_forSale.Count} item(s) for sale across {_stands} stand(s).";
		}

		public static void Invalidate()
		{
			_builtAt = -999f;
		}
	}
	internal static class Chat
	{
		private const string Blue = "#5FC8F0";

		private const string Amber = "#FFD24A";

		private const string Red = "#FF7A63";

		private const string Green = "#7FD99A";

		public static void Info(string msg)
		{
			Send("#5FC8F0", "WARDEN", msg);
		}

		public static void Ask(string msg)
		{
			Send("#FFD24A", "WARDEN", msg);
		}

		public static void Hit(string msg)
		{
			Send("#FF7A63", "WARDEN", msg);
		}

		public static void Ok(string msg)
		{
			Send("#7FD99A", "WARDEN", msg);
		}

		private static void Send(string colour, string tag, string msg)
		{
			if (string.IsNullOrEmpty(msg))
			{
				return;
			}
			Plugin.Log.LogInfo((object)("[Fishwarden] " + Strip(msg)));
			string[] array = msg.Split('\n');
			foreach (string text in array)
			{
				if (text.Length != 0)
				{
					try
					{
						ChatManager.ChatMessage("<color=" + colour + "><b>[" + tag + "]</b></color> " + text);
					}
					catch
					{
					}
				}
			}
		}

		public static void Broadcast(string msg)
		{
			Plugin.Log.LogInfo((object)("[Fishwarden] " + Strip(msg)));
			string text = "<color=#FF7A63><b>[WARDEN]</b></color> " + msg;
			try
			{
				Player localPlayer = Player.LocalPlayer;
				if ((Object)(object)Server.Instance != (Object)null && (Object)(object)localPlayer != (Object)null)
				{
					Server.Instance.SendChatMessage(localPlayer.SteamID, text);
				}
				else
				{
					ChatManager.ChatMessage(text);
				}
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("[Fishwarden] broadcast failed: " + ex.Message));
			}
		}

		public static void AsPlayer(Player who, string msg)
		{
			if ((Object)(object)who == (Object)null || string.IsNullOrEmpty(msg))
			{
				return;
			}
			if (!Plugin.MuteSpeaksAsPlayer.Value)
			{
				Broadcast(msg);
				return;
			}
			Plugin.Log.LogInfo((object)("[Fishwarden] (as " + who.SteamName + ") " + Strip(msg)));
			try
			{
				Server.Instance.SendChatMessage(who.SteamID, msg);
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("[Fishwarden] could not speak as them: " + ex.Message));
			}
		}

		private static string Strip(string s)
		{
			if (s != null)
			{
				return Regex.Replace(s, "<.*?>", "");
			}
			return "";
		}
	}
	internal static class Cheats
	{
		public static bool Immortal;

		public static bool GodMode;

		public static bool InfiniteAmmo;

		public static float MoneyMultiplier = 1f;

		public static float LuckMultiplier = 1f;

		public static float SpeedMultiplier = 1f;

		private static float _nextRevive;

		private static readonly List<GameObject> _mine = new List<GameObject>();

		private static float _walk;

		private static float _sprint;

		private static bool _swapped;

		public static bool OnePunch;

		public static float OnePunchForce = 999999f;

		private static bool _toldPunch;

		private static int _basePunch;

		private static bool _punchSwapped;

		public static bool Stretchy;

		public static float Reach = 20f;

		private static float _baseRange;

		private static float _baseRadius;

		private static float _baseNoPos;

		private static bool _capturedReach;

		public static bool WalkOnWater;

		public static float SurfaceOffset = 0.1f;

		private static List<string> _names;

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

		private static string _filter = "";

		public static int SpawnedCount
		{
			get
			{
				_mine.RemoveAll((GameObject g) => (Object)(object)g == (Object)null);
				return _mine.Count;
			}
		}

		public static string Filter
		{
			get
			{
				return _filter;
			}
			set
			{
				_filter = value;
			}
		}

		public static string ClearSpawned()
		{
			if (!Plugin.IsHosting)
			{
				return "Despawning is server side - host or play solo.";
			}
			_mine.RemoveAll((GameObject g) => (Object)(object)g == (Object)null);
			if (_mine.Count == 0)
			{
				return "Nothing spawned from here is still around.";
			}
			int num = 0;
			foreach (GameObject item in _mine.ToList())
			{
				if ((Object)(object)item == (Object)null)
				{
					continue;
				}
				try
				{
					((NetworkBehaviour)Server.Instance).Despawn(item, (DespawnType?)null);
					num++;
				}
				catch
				{
					try
					{
						Object.Destroy((Object)(object)item);
						num++;
					}
					catch
					{
					}
				}
			}
			_mine.Clear();
			Plugin.Log.LogInfo((object)("[Cheats] cleared " + num + " spawned object(s)."));
			return num + " thing(s) sent away.";
		}

		public static void Tick()
		{
			if (Immortal)
			{
				KeepUp();
			}
		}

		public static bool Hit_Pre(Player __0)
		{
			if (!GodMode)
			{
				return true;
			}
			try
			{
				return (Object)(object)__0 != (Object)(object)Player.LocalPlayer;
			}
			catch
			{
				return true;
			}
		}

		public static void Fixed()
		{
			FixedTick();
		}

		private static void KeepUp()
		{
			if (Time.realtimeSinceStartup < _nextRevive)
			{
				return;
			}
			_nextRevive = Time.realtimeSinceStartup + 0.35f;
			try
			{
				Player localPlayer = Player.LocalPlayer;
				if (!((Object)(object)localPlayer == (Object)null) && !((Object)(object)localPlayer.Vitals == (Object)null) && localPlayer.Vitals.Health <= 0)
				{
					DeadPlayer val = (((Object)(object)localPlayer.Dying != (Object)null) ? localPlayer.Dying.DeadPlayer : null);
					if ((Object)(object)val != (Object)null)
					{
						Server.Instance.ResurrectPlayer(localPlayer, val);
					}
				}
			}
			catch
			{
			}
		}

		public static void Shoot_Pre(Weapon __instance)
		{
			if (!InfiniteAmmo)
			{
				return;
			}
			try
			{
				object value = Traverse.Create((object)__instance).Field("_holder").GetValue();
				Player val = (Player)((value is Player) ? value : null);
				if (!((Object)(object)val == (Object)null) && !((Object)(object)val != (Object)(object)Player.LocalPlayer))
				{
					object value2 = Traverse.Create((object)__instance).Field("_attachments").GetValue();
					Attachments val2 = (Attachments)((value2 is Attachments) ? value2 : null);
					if (!((Object)(object)val2 == (Object)null))
					{
						Traverse.Create((object)__instance).Property("Ammo", (object[])null).SetValue((object)val2.AmmoPerMag);
					}
				}
			}
			catch
			{
			}
		}

		public static void SellItem_Post(Item item)
		{
			if (MoneyMultiplier <= 1.001f)
			{
				return;
			}
			try
			{
				int num = Mathf.RoundToInt((float)item.TotalWorth * (MoneyMultiplier - 1f));
				if (num <= 0)
				{
					Plugin.Log.LogInfo((object)("[Cheats] sale of " + ((Object)item).name + " worth " + item.TotalWorth + " - x" + MoneyMultiplier.ToString("0.0") + " added nothing."));
				}
				else
				{
					MoneyManager.AddMoney(num, Player.LocalPlayer);
					Plugin.Log.LogInfo((object)("[Cheats] sale of " + ((Object)item).name + " worth " + item.TotalWorth + " - x" + MoneyMultiplier.ToString("0.0") + " added " + num + "."));
				}
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("[Cheats] sale bonus failed: " + ex.Message));
			}
		}

		public static void Luck_Pre(List<ItemInfoWeight> __0)
		{
			if (LuckMultiplier <= 1.001f || __0 == null)
			{
				return;
			}
			try
			{
				float num = 1f / Mathf.Max(1f, LuckMultiplier);
				foreach (ItemInfoWeight item in __0)
				{
					if (item == null)
					{
						continue;
					}
					Traverse val = Traverse.Create((object)item).Field("_weight");
					if (val != null && val.FieldExists())
					{
						float value = val.GetValue<float>();
						if (!(value <= 0f))
						{
							val.SetValue((object)Mathf.Max(1f, Mathf.Pow(value, num)));
						}
					}
				}
			}
			catch
			{
			}
		}

		public static void Speed_Pre(PlayerMovement __instance)
		{
			_swapped = false;
			if (SpeedMultiplier <= 1.001f)
			{
				return;
			}
			try
			{
				if (!((Object)(object)Player.LocalPlayer == (Object)null) && !((Object)(object)Player.LocalPlayer.Movement != (Object)(object)__instance))
				{
					Traverse obj = Traverse.Create((object)__instance);
					_walk = obj.Field("_walkSpeed").GetValue<float>();
					_sprint = obj.Field("_sprintSpeed").GetValue<float>();
					obj.Field("_walkSpeed").SetValue((object)(_walk * SpeedMultiplier));
					obj.Field("_sprintSpeed").SetValue((object)(_sprint * SpeedMultiplier));
					_swapped = true;
				}
			}
			catch
			{
			}
		}

		public static void Speed_Fin(PlayerMovement __instance)
		{
			if (!_swapped)
			{
				return;
			}
			_swapped = false;
			try
			{
				Traverse obj = Traverse.Create((object)__instance);
				obj.Field("_walkSpeed").SetValue((object)_walk);
				obj.Field("_sprintSpeed").SetValue((object)_sprint);
			}
			catch
			{
			}
		}

		public static void HitTarget_Pre(PlayerPunching __instance)
		{
			_punchSwapped = false;
			if (!OnePunch)
			{
				return;
			}
			try
			{
				if ((Object)(object)Player.LocalPlayer == (Object)null || ((NetworkBehaviour)__instance).Owner == (NetworkConnection)null || !((NetworkBehaviour)__instance).Owner.IsLocalClient)
				{
					return;
				}
				Traverse val = Traverse.Create((object)__instance).Field("_damage");
				if (val != null && val.FieldExists())
				{
					_basePunch = val.GetValue<int>();
					if (!_toldPunch)
					{
						_toldPunch = true;
						Plugin.Log.LogInfo((object)("[Cheats] vanilla punch damage is " + _basePunch + ". One punch replaces it with " + OnePunchForce.ToString("0") + " for your punches only."));
					}
					val.SetValue((object)Mathf.RoundToInt(Mathf.Max(1f, OnePunchForce)));
					_punchSwapped = true;
				}
			}
			catch
			{
			}
		}

		public static void HitTarget_Fin(PlayerPunching __instance)
		{
			if (!_punchSwapped)
			{
				return;
			}
			_punchSwapped = false;
			try
			{
				Traverse.Create((object)__instance).Field("_damage").SetValue((object)_basePunch);
			}
			catch
			{
			}
		}

		public static void FindPunchTarget_Pre(PlayerPunching __instance)
		{
			try
			{
				if ((Object)(object)Player.LocalPlayer == (Object)null || ((NetworkBehaviour)__instance).Owner == (NetworkConnection)null || !((NetworkBehaviour)__instance).Owner.IsLocalClient)
				{
					return;
				}
				Traverse obj = Traverse.Create((object)__instance);
				Traverse val = obj.Field("_range");
				Traverse val2 = obj.Field("_hitRadius");
				Traverse val3 = obj.Field("_noTargetHitPos");
				if (val == null || !val.FieldExists())
				{
					return;
				}
				if (!_capturedReach)
				{
					_baseRange = val.GetValue<float>();
					_baseRadius = ((val2 != null && val2.FieldExists()) ? val2.GetValue<float>() : 0f);
					_baseNoPos = ((val3 != null && val3.FieldExists()) ? val3.GetValue<float>() : 0f);
					_capturedReach = true;
				}
				if (Stretchy)
				{
					val.SetValue((object)(_baseRange * Reach));
					if (val2 != null && val2.FieldExists())
					{
						val2.SetValue((object)(_baseRadius * Mathf.Min(4f, 1f + Reach * 0.1f)));
					}
					if (val3 != null && val3.FieldExists())
					{
						val3.SetValue((object)(_baseNoPos * Reach));
					}
				}
				else
				{
					val.SetValue((object)_baseRange);
					if (val2 != null && val2.FieldExists())
					{
						val2.SetValue((object)_baseRadius);
					}
					if (val3 != null && val3.FieldExists())
					{
						val3.SetValue((object)_baseNoPos);
					}
				}
			}
			catch
			{
			}
		}

		public static void FixedTick()
		{
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: 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_0091: 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_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			if (!WalkOnWater)
			{
				return;
			}
			try
			{
				Player localPlayer = Player.LocalPlayer;
				if ((Object)(object)localPlayer == (Object)null || localPlayer.BlockInputs)
				{
					return;
				}
				PlayerMovement movement = localPlayer.Movement;
				if ((Object)(object)movement != (Object)null && movement.OnBoat)
				{
					return;
				}
				Rigidbody rigidbody = localPlayer.Rigidbody;
				if ((Object)(object)rigidbody == (Object)null)
				{
					return;
				}
				float num = WaterManager.WaterHeight + SurfaceOffset;
				float y = localPlayer.Transform.position.y;
				if (!(y >= num))
				{
					Vector3 position = rigidbody.position;
					position.y += num - y;
					rigidbody.position = position;
					Vector3 linearVelocity = rigidbody.linearVelocity;
					if (linearVelocity.y < 0f)
					{
						linearVelocity.y = 0f;
						rigidbody.linearVelocity = linearVelocity;
					}
				}
			}
			catch
			{
			}
		}

		public static List<string> Names(string filter)
		{
			if (_names == null)
			{
				_names = new List<string>();
				try
				{
					if (Traverse.Create(typeof(GameInfo)).Field("_nameToSpawnable").GetValue() is IDictionary dictionary)
					{
						foreach (DictionaryEntry item in dictionary)
						{
							object? value = item.Value;
							Item val = (Item)((value is Item) ? value : null);
							if (!((Object)(object)val == (Object)null))
							{
								string text = ((Object)val).name.Replace("(Clone)", "").Trim();
								_names.Add(text);
								string value2 = ((item.Key != null) ? item.Key.ToString() : null);
								if (!string.IsNullOrEmpty(value2) && !_keyOf.ContainsKey(text))
								{
									_keyOf[text] = value2;
								}
							}
						}
					}
					_names = (from x in _names.Distinct()
						orderby x
						select x).ToList();
					Plugin.Log.LogInfo((object)("[Cheats] " + _names.Count + " spawnables (shown -> key):"));
					foreach (string name in _names)
					{
						Plugin.Log.LogInfo((object)("[Cheats]   " + name + "  ->  " + (_keyOf.TryGetValue(name, out var value3) ? value3 : "(no key)")));
					}
				}
				catch
				{
				}
			}
			if (string.IsNullOrWhiteSpace(filter))
			{
				return _names;
			}
			return _names.Where((string n) => n.IndexOf(filter, StringComparison.OrdinalIgnoreCase) >= 0).ToList();
		}

		public static string Spawn(string name)
		{
			//IL_018e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0193: Unknown result type (might be due to invalid IL or missing references)
			//IL_0196: 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_01b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0202: Unknown result type (might be due to invalid IL or missing references)
			//IL_0207: Unknown result type (might be due to invalid IL or missing references)
			//IL_024f: 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)
			if (!Plugin.IsHosting)
			{
				return "Only the host can spawn.";
			}
			try
			{
				Names("");
				if (!_keyOf.TryGetValue(name, out var value) || string.IsNullOrEmpty(value))
				{
					value = name.Replace(" ", "").ToLowerInvariant();
				}
				string text = name.Replace(" ", "").ToLowerInvariant();
				List<string> list = new List<string>();
				GameObject val = null;
				string[] array = new string[3]
				{
					value,
					value.ToLowerInvariant(),
					text
				};
				foreach (string text2 in array)
				{
					if (!string.IsNullOrEmpty(text2) && !list.Contains(text2))
					{
						list.Add(text2);
						Item spawnable = GameInfo.GetSpawnable(text2);
						if (!((Object)(object)spawnable == (Object)null))
						{
							val = ((Component)spawnable).gameObject;
							break;
						}
					}
				}
				if ((Object)(object)val == (Object)null)
				{
					Plugin.Log.LogWarning((object)("[Cheats] no spawnable for '" + name + "' - tried " + string.Join(", ", list.ToArray())));
					return "No item called " + name + " - looked under " + string.Join(" and ", list.Select((string x) => "\"" + x + "\"").ToArray()) + ".";
				}
				Player localPlayer = Player.LocalPlayer;
				if ((Object)(object)localPlayer == (Object)null)
				{
					return "No local player to spawn in front of.";
				}
				Vector3 val2 = Body.InFrontOf(localPlayer);
				GameObject val3 = Object.Instantiate<GameObject>(val, val2, Quaternion.identity);
				((NetworkBehaviour)Server.Instance).Spawn(val3.gameObject, (NetworkConnection)null, default(Scene));
				_mine.RemoveAll((GameObject g) => (Object)(object)g == (Object)null);
				_mine.Add(val3.gameObject);
				Vector3 position = val3.transform.position;
				ManualLogSource log = Plugin.Log;
				string[] obj = new string[8]
				{
					"[Cheats] spawned '",
					name,
					"' as key '",
					value,
					"' at ",
					((Vector3)(ref position)).ToString("0.0"),
					" - you are at ",
					null
				};
				Vector3 val4 = Body.Of(localPlayer);
				obj[7] = ((Vector3)(ref val4)).ToString("0.0");
				log.LogInfo((object)string.Concat(obj));
				Item component = val3.GetComponent<Item>();
				string text3 = (((Object)(object)component != (Object)null) ? Handed(localPlayer, component) : null);
				return "Spawned " + ((Object)val).name + (text3 ?? " just in front of you.");
			}
			catch (Exception ex)
			{
				return "Could not spawn: " + ex.Message;
			}
		}

		private static string Handed(Player who, Item item)
		{
			try
			{
				if ((Object)(object)item.Creature != (Object)null)
				{
					Plugin.Log.LogInfo((object)("[Cheats] " + ((Object)item).name + " is a creature - left where it landed rather than put in your hands."));
					return " in front of you - creatures are not held.";
				}
			}
			catch
			{
			}
			if (Call(item, "PickUp", who, item))
			{
				Plugin.Log.LogInfo((object)("[Cheats] " + ((Object)item).name + " picked up through the game's own path."));
				return " into your hands.";
			}
			if (!Call(who.Holding, "SetHeldItem", who, item))
			{
				Report(who.Holding, "SetHeldItem");
				return null;
			}
			bool num = Call(who.Holding, "ServerTryStoreHeldItem", who, item) || Call(Server.Instance, "ServerTryStoreHeldItem", who, item);
			Plugin.Log.LogWarning((object)("[Cheats] Item.PickUp did not match - fell back to SetHeldItem, so " + ((Object)item).name + " may not be attached properly."));
			if (!num)
			{
				return " into your hands.";
			}
			return " into your inventory.";
		}

		private static bool Call(object target, string method, Player who, Item item)
		{
			if (target == null)
			{
				return false;
			}
			try
			{
				MethodInfo[] methods = target.GetType().GetMethods(AccessTools.all);
				foreach (MethodInfo methodInfo in methods)
				{
					if (methodInfo.Name != method)
					{
						continue;
					}
					ParameterInfo[] parameters = methodInfo.GetParameters();
					object[] array = new object[parameters.Length];
					bool flag = true;
					for (int j = 0; j < parameters.Length; j++)
					{
						Type parameterType = parameters[j].ParameterType;
						if (parameterType.IsInstanceOfType(item))
						{
							array[j] = item;
							continue;
						}
						if (parameterType.IsInstanceOfType(who))
						{
							array[j] = who;
							continue;
						}
						if (parameterType == typeof(bool))
						{
							array[j] = true;
							continue;
						}
						if (parameterType.IsValueType)
						{
							array[j] = Activator.CreateInstance(parameterType);
							continue;
						}
						flag = false;
						break;
					}
					if (flag)
					{
						methodInfo.Invoke(target, array);
						Plugin.Log.LogInfo((object)("[Cheats] called " + target.GetType().Name + "." + methodInfo.Name + "(" + parameters.Length + " args)."));
						return true;
					}
				}
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("[Cheats] " + method + " failed: " + ex.Message));
			}
			return false;
		}

		private static void Report(object target, string wanted)
		{
			if (target == null)
			{
				Plugin.Log.LogWarning((object)"[Cheats] no holder to give it to.");
				return;
			}
			try
			{
				string[] value = (from n in (from m in target.GetType().GetMethods(AccessTools.all)
						select m.Name into n
						where n.IndexOf("Item", StringComparison.OrdinalIgnoreCase) >= 0
						select n).Distinct()
					orderby n
					select n).ToArray();
				Plugin.Log.LogWarning((object)("[Cheats] no " + wanted + " on " + target.GetType().Name + ". Item-related methods it DOES have: " + string.Join(", ", value)));
			}
			catch
			{
			}
		}

		public static void Install(Harmony h)
		{
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Expected O, but got Unknown
			//IL_015d: Unknown result type (might be due to invalid IL or missing references)
			//IL_016b: Expected O, but got Unknown
			List<string> attached = new List<string>();
			List<string> missing = new List<string>();
			Patch(typeof(Server), "HitPlayer", "Hit_Pre");
			Patch(typeof(Weapon), "Shoot", "Shoot_Pre");
			Patch(typeof(PlayerPunching), "HitTarget", "HitTarget_Pre", "HitTarget_Fin");
			Patch(typeof(PlayerPunching), "FindPunchTarget", "FindPunchTarget_Pre");
			Patch(typeof(PlayerMovement), "UpdateMoveSpeed", "Speed_Pre", "Speed_Fin");
			try
			{
				MethodInfo methodInfo = AccessTools.Method(typeof(MoneyManager), "SellItem", (Type[])null, (Type[])null);
				if (methodInfo != null)
				{
					h.Patch((MethodBase)methodInfo, (HarmonyMethod)null, new HarmonyMethod(AccessTools.Method(typeof(Cheats), "SellItem_Post", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				}
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("[Cheats] SellItem: " + ex.Message));
			}
			try
			{
				MethodInfo methodInfo2 = AccessTools.Method(typeof(CreatureManager), "GetRandomItem", (Type[])null, (Type[])null);
				if (methodInfo2 != null)
				{
					h.Patch((MethodBase)methodInfo2, new HarmonyMethod(AccessTools.Method(typeof(Cheats), "Luck_Pre", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				}
			}
			catch (Exception ex2)
			{
				Plugin.Log.LogWarning((object)("[Cheats] GetRandomItem: " + ex2.Message));
			}
			Plugin.Log.LogInfo((object)("[Cheats] hooked: " + string.Join(", ", attached.ToArray())));
			if (missing.Count > 0)
			{
				Plugin.Log.LogWarning((object)("[Cheats] NOT hooked: " + string.Join(", ", missing.ToArray()) + " - whatever those did will do nothing."));
			}
			Plugin.Log.LogWarning((object)"[Cheats] FULL BUILD - private tools are active. Do not hand this DLL out.");
			void Patch(Type type, string method, string pre, string fin = null)
			{
				//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
				try
				{
					MethodInfo methodInfo3 = AccessTools.Method(type, method, (Type[])null, (Type[])null);
					if (methodInfo3 == null)
					{
						Plugin.Log.LogWarning((object)("[Cheats] " + type.Name + "." + method + " not found"));
						missing.Add(type.Name + "." + method);
					}
					else
					{
						attached.Add(type.Name + "." + method);
						h.Patch((MethodBase)methodInfo3, (pre == null) ? ((HarmonyMethod)null) : new HarmonyMethod(AccessTools.Method(typeof(Cheats), pre, (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (fin == null) ? ((HarmonyMethod)null) : new HarmonyMethod(AccessTools.Method(typeof(Cheats), fin, (Type[])null, (Type[])null)), (HarmonyMethod)null);
					}
				}
				catch (Exception ex3)
				{
					Plugin.Log.LogWarning((object)("[Cheats] " + method + ": " + ex3.Message));
				}
			}
		}
	}
	internal static class ClientGuard
	{
		private static float _nextBark;

		private static int _swallowed;

		private static float _islandGraceUntil = -1f;

		private static int _lastIsland = -1;

		private static void Bark(string msg)
		{
			float realtimeSinceStartup = Time.realtimeSinceStartup;
			if (realtimeSinceStartup < _nextBark)
			{
				_swallowed++;
				return;
			}
			_nextBark = realtimeSinceStartup + 1f;
			Plugin.Log.LogWarning((object)(msg + ((_swallowed > 0) ? $"  (+{_swallowed} more in the last second)" : "")));
			_swallowed = 0;
		}

		public static bool Teleport_Pre(Player __instance, NetworkConnection __0, Vector3 __1, float __2)
		{
			//IL_0032: 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_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: 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)
			try
			{
				Player localPlayer = Player.LocalPlayer;
				if ((Object)(object)localPlayer == (Object)null || (Object)(object)__instance != (Object)(object)localPlayer)
				{
					return true;
				}
				if (Time.realtimeSinceStartup < _islandGraceUntil)
				{
					return true;
				}
				if (!Body.Sane(__1))
				{
					Bark("[Anchor] refused a teleport to coordinates that are not a place - this crashes the game and has been dropped.");
					return false;
				}
				float num = Vector3.Distance(Body.Of(localPlayer), __1);
				if (num < Plugin.AnchorMinDistance.Value)
				{
					return true;
				}
				string text = $"something moved you {num:0}m to {__1.x:0},{__1.y:0},{__1.z:0}";
				if (!Plugin.Anchor.Value)
				{
					Bark("[Anchor] " + text + " (Anchor is off - allowed)");
					Notice("[Fishwarden] " + text);
					return true;
				}
				Bark("[Anchor] refused: " + text);
				Notice("[Fishwarden] refused a teleport - " + text);
				return false;
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("[Anchor] check failed, allowing: " + ex.Message));
				return true;
			}
		}

		public static void Tick()
		{
			try
			{
				byte curIsland = OnlineIslandManager.CurIsland;
				if (curIsland != _lastIsland)
				{
					_lastIsland = curIsland;
					_islandGraceUntil = Time.realtimeSinceStartup + Plugin.IslandGraceSeconds.Value;
				}
			}
			catch
			{
			}
		}

		private static void Notice(string msg)
		{
			Chat.Hit(msg);
		}
	}
	internal static class ClientWatch
	{
		private sealed class Track
		{
			public Vector3 LastPos;

			public float LastTime;

			public int Over;

			public float AirborneSince = -1f;

			public float LastReport = -999f;

			public bool Primed;
		}

		private static readonly Dictionary<Player, Track> _tracks = new Dictionary<Player, Track>();

		private static readonly Dictionary<string, int> _suspects = new Dictionary<string, int>();

		private static float _nextSample;

		public static IReadOnlyDictionary<string, int> Suspects => _suspects;

		public static void Tick()
		{
			if (Plugin.IsHosting || !Plugin.WatchAsClient.Value)
			{
				return;
			}
			float realtimeSinceStartup = Time.realtimeSinceStartup;
			if (realtimeSinceStartup < _nextSample)
			{
				return;
			}
			_nextSample = realtimeSinceStartup + 0.1f;
			try
			{
				foreach (Player player in PlayerManager.Players)
				{
					if (!((Object)(object)player == (Object)null) && !((Object)(object)player == (Object)(object)Player.LocalPlayer))
					{
						Sample(player, realtimeSinceStartup);
					}
				}
			}
			catch
			{
			}
		}

		private static void Sample(Player p, float now)
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: 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_005c: 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_005f: 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_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: 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)
			if (!_tracks.TryGetValue(p, out var value))
			{
				value = new Track();
				_tracks[p] = value;
			}
			Vector3 val = Body.Of(p);
			if (!value.Primed)
			{
				value.LastPos = val;
				value.LastTime = now;
				value.Primed = true;
				return;
			}
			float num = now - value.LastTime;
			value.LastTime = now;
			Vector3 lastPos = value.LastPos;
			value.LastPos = val;
			if (num < 0.05f || num > 1f)
			{
				value.Over = 0;
				return;
			}
			Vector3 val2 = default(Vector3);
			((Vector3)(ref val2))..ctor(val.x - lastPos.x, 0f, val.z - lastPos.z);
			float num2 = ((Vector3)(ref val2)).magnitude / num;
			float num3 = Plugin.FallbackSpeedCeiling.Value * Mathf.Max(1f, Plugin.SlackLine.Value);
			if (num2 > num3)
			{
				value.Over++;
				if (value.Over >= Plugin.SpeedSamples.Value && now - value.LastReport > Plugin.MovementFindingCooldown.Value)
				{
					value.LastReport = now;
					value.Over = 0;
					Flag(p, $"moving at {num2:0} u/s (ceiling {num3:0})");
				}
			}
			else
			{
				value.Over = 0;
			}
			bool flag;
			try
			{
				flag = (Object)(object)p.Movement != (Object)null && !p.Movement.Grounded && !p.Movement.OnBoat;
			}
			catch
			{
				flag = false;
			}
			if (!flag)
			{
				value.AirborneSince = -1f;
				return;
			}
			if (value.AirborneSince < 0f)
			{
				value.AirborneSince = now;
			}
			float num4 = now - value.AirborneSince;
			if (num4 > Plugin.FlightSeconds.Value && now - value.LastReport > Plugin.MovementFindingCooldown.Value)
			{
				value.LastReport = now;
				value.AirborneSince = now;
				Flag(p, $"airborne {num4:0.0}s with no boat");
			}
		}

		private static void Flag(Player p, string what)
		{
			string text = p.SteamName ?? "?";
			_suspects.TryGetValue(text, out var value);
			_suspects[text] = value + 1;
			Plugin.Log.LogWarning((object)$"[FishFinder] {text}: {what}  (x{value + 1})");
		}

		public static string Readout()
		{
			if (_suspects.Count == 0)
			{
				return "Fish Finder: nothing unusual seen.";
			}
			List<string> list = new List<string> { "Fish Finder - what I saw from here:" };
			foreach (KeyValuePair<string, int> suspect in _suspects)
			{
				list.Add($"  {suspect.Key}: {suspect.Value} anomalies");
			}
			list.Add("(seen as a guest - I cannot prove intent, only what my client rendered)");
			return string.Join("\n", list);
		}

		public static void Reset()
		{
			_tracks.Clear();
			_suspects.Clear();
		}
	}
	internal static class Commands
	{
		private static readonly string[] Ours = new string[40]
		{
			"net", "level", "rule", "warden", "logbook", "report", "crew", "uncrew", "pardon", "gut",
			"chum", "skunk", "unskunk", "cooler", "uncooler", "locker", "blowback", "butterfingers", "troll", "wall",
			"unban", "finder", "anchor", "help", "cases", "accept", "dismiss", "autokick", "trace", "summary",
			"selftest", "stress", "island", "fly", "purge", "mute", "freeze", "lockdown", "strip", "autotroll"
		};

		public static void Install(Harmony h)
		{
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Expected O, but got Unknown
			MethodInfo methodInfo = AccessTools.Method(typeof(DazedCommands), "IsServerCommand", (Type[])null, (Type[])null);
			if (methodInfo == null)
			{
				Plugin.Log.LogWarning((object)"[Fishwarden] chat commands unavailable - IsServerCommand not found.");
			}
			else
			{
				h.Patch((MethodBase)methodInfo, new HarmonyMethod(AccessTools.Method(typeof(Commands), "Pre", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			}
		}

		private static bool Pre(string fullCommand, ref bool __result)
		{
			try
			{
				if (string.IsNullOrEmpty(fullCommand) || !fullCommand.StartsWith("/"))
				{
					return true;
				}
				string text = fullCommand.Substring(1).Trim();
				if (text.Length == 0)
				{
					return true;
				}
				int num = text.IndexOf(' ');
				string text2 = ((num < 0) ? text : text.Substring(0, num)).ToLowerInvariant();
				string text3 = ((num < 0) ? "" : text.Substring(num + 1).Trim());
				if (text2 == "help" && !text3.StartsWith("warden", StringComparison.OrdinalIgnoreCase))
				{
					return true;
				}
				if (!Ours.Contains(text2))
				{
					return true;
				}
				Handle(text2, text3);
				__result = true;
				return false;
			}
			catch (Exception ex)
			{
				Plugin.Log.LogError((object)("[Fishwarden] command error: " + ex));
				return true;
			}
		}

		private static void Handle(string cmd, string arg)
		{
			if (cmd == null)
			{
				return;
			}
			switch (cmd.Length)
			{
			case 4:
				switch (cmd[0])
				{
				case 'h':
					if (cmd == "help")
					{
						Help();
					}
					break;
				case 'r':
					if (cmd == "rule")
					{
						Rule(arg);
					}
					break;
				case 'c':
					if (!(cmd == "crew"))
					{
						if (cmd == "chum")
						{
							HostOnly(() => (!Extras.ChumOut) ? Extras.DropChum() : DropOrClear());
						}
					}
					else
					{
						WithPlayer(arg, Crew.Grant);
					}
					break;
				case 'w':
					if (cmd == "wall")
					{
						Wall();
					}
					break;
				case 'm':
					if (cmd == "mute")
					{
						Mute(arg);
					}
					break;
				}
				break;
			case 3:
				switch (cmd[0])
				{
				default:
					return;
				case 'n':
					break;
				case 'g':
					if (cmd == "gut")
					{
						Gut(arg);
					}
					return;
				case 'f':
					if (cmd == "fly")
					{
						Say(HostTools.ToggleFly());
					}
					return;
				}
				if (!(cmd == "net"))
				{
					break;
				}
				goto IL_0452;
			case 5:
				switch (cmd[1])
				{
				default:
					return;
				case 'e':
					break;
				case 'k':
					if (cmd == "skunk")
					{
						WithPlayer(arg, Extras.Skunk);
					}
					return;
				case 'r':
					if (!(cmd == "troll"))
					{
						if (cmd == "trace")
						{
							TraceCmd(arg);
						}
					}
					else
					{
						WithPlayer(arg, Troll.Toggle);
					}
					return;
				case 'n':
					if (cmd == "unban")
					{
						Unban(arg);
					}
					return;
				case 'a':
					if (cmd == "cases")
					{
						Say(Cases.List());
					}
					return;
				case 'u':
					if (cmd == "purge")
					{
						if (arg.Equals("all", StringComparison.OrdinalIgnoreCase))
						{
							Say(Actions.PurgeAll());
						}
						else
						{
							WithPlayer(arg, Actions.Purge);
						}
					}
					return;
				case 't':
					if (cmd == "strip")
					{
						WithPlayer(arg, Actions.Strip);
					}
					return;
				}
				if (!(cmd == "level"))
				{
					break;
				}
				goto IL_0452;
			case 6:
				switch (cmd[0])
				{
				default:
					return;
				case 'w':
					break;
				case 'r':
					if (cmd == "report")
					{
						Report();
					}
					return;
				case 'u':
					if (cmd == "uncrew")
					{
						WithPlayer(arg, Crew.Revoke);
					}
					return;
				case 'p':
					if (cmd == "pardon")
					{
						WithPlayer(arg, delegate(Player p)
						{
							Logbook.Pardon(p.SteamID);
							Rollback.Clear(p.SteamID);
							Extras.Release(p.SteamID);
							return p.SteamName + " pardoned - strikes cleared.";
						});
					}
					return;
				case 'c':
					if (cmd == "cooler")
					{
						WithPlayer(arg, Extras.Cool);
					}
					return;
				case 'l':
					if (cmd == "locker")
					{
						WithPlayer(arg, Extras.Locker);
					}
					return;
				case 'f':
					if (!(cmd == "finder"))
					{
						if (cmd == "freeze")
						{
							WithPlayer(arg, Actions.ToggleFreeze);
						}
					}
					else
					{
						Say(ClientWatch.Readout());
					}
					return;
				case 'a':
					if (!(cmd == "anchor"))
					{
						if (cmd == "accept")
						{
							Decide(arg, accept: true);
						}
					}
					else
					{
						Anchor();
					}
					return;
				case 'i':
					if (cmd == "island")
					{
						Island(arg);
					}
					return;
				case 's':
				{
					if (!(cmd == "stress"))
					{
						return;
					}
					if (!int.TryParse(arg, out var result))
					{
						result = 20000;
					}
					{
						foreach (string item in SelfTest.Stress(result))
						{
							Say(item);
						}
						return;
					}
				}
				}
				if (!(cmd == "warden"))
				{
					break;
				}
				goto IL_0452;
			case 7:
				switch (cmd[0])
				{
				case 'l':
					if (cmd == "logbook")
					{
						Recent();
					}
					break;
				case 'u':
					if (cmd == "unskunk")
					{
						WithPlayer(arg, Extras.Unskunk);
					}
					break;
				case 'd':
					if (cmd == "dismiss")
					{
						Decide(arg, accept: false);
					}
					break;
				case 's':
					if (!(cmd == "summary"))
					{
						break;
					}
					{
						foreach (string item2 in Summary.Lines())
						{
							Say(item2);
						}
						break;
					}
				}
				break;
			case 8:
				switch (cmd[0])
				{
				case 'u':
					if (cmd == "uncooler")
					{
						WithPlayer(arg, Extras.Uncool);
					}
					break;
				case 'b':
					if (cmd == "blowback")
					{
						WithPlayer(arg, Extras.Blowback);
					}
					break;
				case 'a':
					if (cmd == "autokick")
					{
						AutoKick(arg);
					}
					break;
				case 'l':
					if (cmd == "lockdown")
					{
						Say(Actions.ToggleLockdown());
					}
					break;
				case 's':
					if (!(cmd == "selftest"))
					{
						break;
					}
					{
						foreach (string item3 in SelfTest.Run())
						{
							Say(item3);
						}
						break;
					}
				}
				break;
			case 13:
				if (cmd == "butterfingers")
				{
					WithPlayer(arg, Extras.Butterfingers);
				}
				break;
			case 9:
				if (cmd == "autotroll")
				{
					AutoTrollCmd(arg);
				}
				break;
			case 10:
			case 11:
			case 12:
				break;
				IL_0452:
				Net(arg);
				break;
			}
		}

		private static string DropOrClear()
		{
			Extras.ClearChum();
			return "Chum cleared.";
		}

		private static void Help()
		{
			Say("Fishwarden 2.0.0");
			Say("  /level watch|block|strict|lockdown    /level status");
			Say("  /logbook  /report  /wall  /unban <n>");
			Say("  /crew <n>  /uncrew <n>  /pardon <n>  /gut <n|all>");
			Say("  /chum  /skunk <n>  /cooler <n>  /locker <n>");
			Say("  /blowback <n>  /butterfingers <n>  /troll <n>");
			Say("  /mute <n> [swearing|racism|antisemitism|politics|shouting]");
			Say("  /freeze <n>  /strip <n>  /purge <n|all>  /lockdown");
			Say("  /cases  /accept <n|all>  /dismiss <n|all>  /autokick on|off  /rule off <name>");
			Say("  /summary  -  what everyone has been trying");
			Say("  /selftest  -  check the guard is behaving   /stress [n]");
			Say("  /island <n>|next|prev  -  move the whole lobby   /fly");
			Say("  /trace  -  what got called that I have no rule for");
			Say("  /finder (as a guest)  /anchor");
		}

		private static void Net(string arg)
		{
			if (string.IsNullOrEmpty(arg))
			{
				Status();
				return;
			}
			switch (arg.ToLowerInvariant())
			{
			case "watch":
				Plugin.SetLevel(Level.Watch);
				break;
			case "block":
				Plugin.SetLevel(Level.Block);
				break;
			case "strict":
				Plugin.SetLevel(Level.Strict);
				break;
			case "lockdown":
				Plugin.SetLevel(Level.Lockdown);
				break;
			case "status":
				Status();
				return;
			default:
			{
				Presets.Preset preset = Presets.Find(arg);
				if (preset != null)
				{
					Say(Presets.Apply(preset));
					return;
				}
				Say("usage: /level watch | block | strict | lockdown");
				Say("   or a preset: " + string.Join(", ", Presets.All.Select((Presets.Preset x) => x.Name)));
				return;
			}
			}
			Say(Policy.Spell());
		}

		private static void Rule(string arg)
		{
			if (string.IsNullOrWhiteSpace(arg))
			{
				Say((Rules.DisabledCount == 0) ? "Every rule is switched on." : ("Not checking: " + string.Join(", ", Rules.Disabled)));
				Say("usage: /rule off <name>  |  /rule on <name>");
				return;
			}
			int num = arg.IndexOf(' ');
			if (num < 0)
			{
				Say("usage: /rule off <name>  |  /rule on <name>");
				return;
			}
			string text = arg.Substring(0, num).ToLowerInvariant();
			string text2 = arg.Substring(num + 1).Trim();
			if (text == "off")
			{
				Say(Rules.Disable(text2) ? ("'" + text2 + "' switched off.") : ("'" + text2 + "' was already off."));
			}
			else if (text == "on")
			{
				Say(Rules.Enable(text2) ? ("'" + text2 + "' switched back on.") : ("'" + text2 + "' was already on."));
			}
			else
			{
				Say("usage: /rule off <name>  |  /rule on <name>");
			}
		}

		private static void Status()
		{
			if (!TackleCheck.Passed)
			{
				Say("Fishwarden is DISARMED - the game changed and the guard could not attach.");
				{
					foreach (string item in TackleCheck.Failures.Take(4))
					{
						Say("  " + item);
					}
					return;
				}
			}
			Say("Fishwarden 2.0.0 - " + Policy.Spell() + " - " + TackleCheck.Summary());
			if (!Plugin.IsHosting)
			{
				Say("  guest: nothing to enforce here. /finder for what I have seen.");
				return;
			}
			Say("  " + Catalogue.Summary());
			Say("  auto-kick: " + (Plugin.AutoKick.Value ? "ON" : "OFF - cases wait for you"));
			if (Cases.PendingCount > 0)
			{
				Say($"  {Cases.PendingCount} case(s) waiting - /cases");
			}
			string text = Extras.Status();
			if (text.Length > 0)
			{
				Say("  " + text);
			}
			Dictionary<ulong, int> dictionary = Logbook.Tally();
			if (dictionary.Count == 0)
			{
				Say("  no findings this session - clean water.");
				return;
			}
			foreach (KeyValuePair<ulong, int> item2 in dictionary.OrderByDescending((KeyValuePair<ulong, int> k) => k.Value))
			{
				Say($"  {Logbook.Name(item2.Key)}: {item2.Value} strikes" + ((item2.Value >= Plugin.KickThreshold.Value) ? " (over threshold)" : "") + (Rollback.HasDamage(item2.Key) ? " - /gut to undo" : ""));
			}
		}

		private static void Recent()
		{
			List<Entry> list = Logbook.Tail(8);
			if (list.Count == 0)
			{
				Say("Logbook is empty.");
				return;
			}
			foreach (Entry item in list)
			{
				Say(item.Line);
			}
		}

		private static void Report()
		{
			try
			{
				Directory.CreateDirectory(Logbook.Folder);
				string text = Path.Combine(Logbook.Folder, "report_" + DateTime.Now.ToString("yyyy-MM-dd_HHmmss") + ".txt");
				File.WriteAllText(text, Logbook.Report());
				Say("Report written: " + text);
			}
			catch (Exception ex)
			{
				Say("Could not write the report: " + ex.Message);
			}
		}

		private static void Gut(string arg)
		{
			if (!Plugin.IsHosting)
			{
				Say("Only the host can undo anything.");
				return;
			}
			if (arg.Equals("all", StringComparison.OrdinalIgnoreCase))
			{
				Say(Rollback.RestoreWorld());
				return;
			}
			WithPlayer(arg, (Player p) => Rollback.Gut(p.SteamID));
		}

		private static void Wall()
		{
			if (Bans.Count == 0)
			{
				Say("Trophy wall is empty.");
				return;
			}
			Say($"Trophy wall ({Bans.Count}):");
			foreach (Bans.Record item in Bans.All.Take(12))
			{
				Say($"  {item.Name} - {item.Reason} ({item.When:yyyy-MM-dd})");
			}
		}

		private static void Unban(string arg)
		{
			if (string.IsNullOrWhiteSpace(arg))
			{
				Say("Who? /wall lists them.");
				return;
			}
			Bans.Record record = Bans.Find(arg);
			if (record == null)
			{
				Say("Nobody on the wall matching \"" + arg + "\".");
				return;
			}
			Bans.Remove(record.SteamId);
			Say(record.Name + " taken off the wall - they can rejoin.");
		}

		private static void Decide(string arg, bool accept)
		{
			int result;
			if (!Plugin.IsHosting)
			{
				Say("Only the host reviews cases.");
			}
			else if (string.IsNullOrWhiteSpace(arg))
			{
				Say(accept ? "Accept which? /cases lists them." : "Dismiss which? /cases lists them.");
			}
			else if (arg.Equals("all", StringComparison.OrdinalIgnoreCase))
			{
				Say(accept ? Cases.AcceptAll() : Cases.DismissAll());
			}
			else if (!int.TryParse(arg.TrimStart('#'), out result))
			{
				Say("'" + arg + "' is not a case number. /cases lists them.");
			}
			else
			{
				Say(accept ? Cases.Accept(result) : Cases.Dismiss(result));
			}
		}

		private static void AutoKick(string arg)
		{
			string text = arg.ToLowerInvariant();
			switch (text)
			{
			case "on":
			case "true":
				Plugin.AutoKick.Value = true;
				break;
			case "off":
			case "false":
				Plugin.AutoKick.Value = false;
				break;
			default:
				if (text.Length == 0)
				{
					Plugin.AutoKick.Value = !Plugin.AutoKick.Value;
					break;
				}
				Say("usage: /autokick on | off");
				return;
			}
			Say(Plugin.AutoKick.Value ? "Auto-kick ON - players are removed as soon as they cross the threshold." : "Auto-kick OFF - crossing the threshold opens a case for you to accept or dismiss.");
		}

		private static void AutoTrollCmd(string arg)
		{
			string text = (arg ?? "").Trim().ToLowerInvariant();
			if (text.Length == 0)
			{
				Say(AutoTroll.Summary());
				Say("usage: /autotroll off | proven | strikes | rules");
				return;
			}
			switch (text)
			{
			case "off":
				AutoTroll.SetMode(AutoTroll.Trigger.Off);
				break;
			case "proven":
				AutoTroll.SetMode(AutoTroll.Trigger.AnyProven);
				break;
			case "strikes":
				AutoTroll.SetMode(AutoTroll.Trigger.AfterStrikes);
				break;
			case "rules":
				AutoTroll.SetMode(AutoTroll.Trigger.ChosenRules);
				break;
			default:
				Say("usage: /autotroll off | proven | strikes | rules");
				return;
			}
			Say(AutoTroll.Summary());
		}

		private static void Mute(string arg)
		{
			MuteLines.Reason reason = MuteLines.Reason.General;
			string text = arg ?? "";
			int num = text.LastIndexOf(' ');
			if (num > 0)
			{
				string text2 = text.Substring(num + 1);
				if (Enum.TryParse<MuteLines.Reason>(text2, ignoreCase: true, out var result))
				{
					reason = result;
					text = text.Substring(0, num);
				}
				else if (text2.Equals("politics", StringComparison.OrdinalIgnoreCase))
				{
					reason = MuteLines.Reason.Political;
					text = text.Substring(0, num);
				}
			}
			Player val = Find(text);
			if (!((Object)(object)val == (Object)null))
			{
				Say(Actions.ToggleMute(val, reason));
			}
		}

		private static void Island(string arg)
		{
			string text = (arg ?? "").Trim().ToLowerInvariant();
			if (text.Length != 0)
			{
				switch (text)
				{
				case "status":
					break;
				case "next":
					Say(HostTools.Next(backwards: false));
					return;
				case "prev":
				case "back":
					Say(HostTools.Next(backwards: true));
					return;
				default:
				{
					if (!int.TryParse(text, out var result))
					{
						Say("usage: /island <number> | next | prev");
					}
					else
					{
						Say(HostTools.GoTo(result - 1));
					}
					return;
				}
				}
			}
			Say(HostTools.Where());
			Say("usage: /island <number> | next | prev");
		}

		private static void TraceCmd(string arg)
		{
			switch (arg.ToLowerInvariant())
			{
			case "on":
				Plugin.TraceUnguarded.Value = true;
				Say("Trace on - unguarded RPCs will be logged.");
				break;
			case "off":
				Plugin.TraceUnguarded.Value = false;
				Plugin.TraceEverything.Value = false;
				Say("Trace off.");
				break;
			case "all":
				Plugin.TraceUnguarded.Value = true;
				Plugin.TraceEverything.Value = true;
				Say("Logging EVERY client RPC. Reproduce the thing once, then /trace off.");
				Say("Needs a restart to tap the guarded ones as well.");
				break;
			default:
				Say(Trace.Summary());
				break;
			}
		}

		private static void Anchor()
		{
			Plugin.Anchor.Value = !Plugin.Anchor.Value;
			Say("Anchor " + (Plugin.Anchor.Value ? "ON - teleports aimed at you will be refused." : "OFF - teleports are allowed but still logged."));
		}

		private static void HostOnly(Func<string> f)
		{
			if (!Plugin.IsHosting)
			{
				Say("Only the host can do that.");
			}
			else
			{
				Say(f());
			}
		}

		private static void WithPlayer(string arg, Func<Player, string> f)
		{
			Player val = Find(arg);
			if (!((Object)(object)val == (Object)null))
			{
				Say(f(val));
			}
		}

		private static Player Find(string query)
		{
			if (string.IsNullOrWhiteSpace(query))
			{
				Say("Who? Try /net status for names.");
				return null;
			}
			List<Player> list = new List<Player>();
			try
			{
				foreach (Player player in PlayerManager.Players)
				{
					if ((Object)(object)player != (Object)null && (Object)(object)player != (Object)(object)Player.LocalPlayer)
					{
						list.Add(player);
					}
				}
			}
			catch
			{
			}
			if (list.Count == 0)
			{
				Say("Nobody else is here.");
				return null;
			}
			string q = Clean(query);
			List<Player> list2 = list.Where((Player p) => Clean(p.SteamName) == q).ToList();
			if (list2.Count == 1)
			{
				return list2[0];
			}
			if (list2.Count > 1)
			{
				Ambiguous(list2);
				return null;
			}
			List<Player> list3 = list.Where(delegate(Player p)
			{
				string text = Clean(p.SteamName);
				return text.Length > 0 && (text.Contains(q) || q.Contains(text));
			}).ToList();
			if (list3.Count == 1)
			{
				Say("(matched \"" + query + "\" to " + list3[0].SteamName + ")");
				return list3[0];
			}
			if (list3.Count > 1)
			{
				Ambiguous(list3);
				return null;
			}
			Say("No player matching \"" + query + "\".");
			return null;
		}

		private static void Ambiguous(List<Player> hits)
		{
			Say("That matches more than one player - be more specific: " + string.Join(", ", hits.Select((Player p) => p.SteamName)));
		}

		private static string Clean(string s)
		{
			if (string.IsNullOrEmpty(s))
			{
				return "";
			}
			s = Regex.Replace(s, "<.*?>", "");
			return Regex.Replace(s, "[^a-zA-Z0-9]", "").ToLowerInvariant();
		}

		private static void Say(string msg)
		{
			Chat.Info(msg);
		}
	}
	internal static class Crash
	{
		private static Traverse _hats;

		private static Traverse _outfits;

		private static Traverse _accessories;

		private static bool _resolved;

		private static void Resolve()
		{
			if (_resolved)
			{
				return;
			}
			_resolved = true;
			try
			{
				Traverse obj = Traverse.Create(typeof(SkinManager));
				_hats = obj.Field("_allHats");
				_outfits = obj.Field("_allOutfits");
				_accessories = obj.Field("_allAccessories");
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("[Crash] could not read the skin lists: " + ex.Message));
			}
		}

		private static int CountOf(Traverse list)
		{
			try
			{
				if (list == null || !list.FieldExists())
				{
					return -1;
				}
				return (list.GetValue() as IList)?.Count ?? (-1);
			}
			catch
			{
				return -1;
			}
		}

		public static bool SpawnPlayer_Pre(byte __10, byte __11, byte __12, NetworkConnection __14)
		{
			if (!Plugin.IsHosting || !TackleCheck.Passed)
			{
				return true;
			}
			if (!Plugin.BlockCrashPackets.Value)
			{
				return true;
			}
			if (Sender.IsTrusted(__14))
			{
				return true;
			}
			int num = BodiesFor(__14);
			if (num >= 1)
			{
				Plugin.Log.LogError((object)("[Fishwarden] BLOCKED CLONE from " + Sender.NameOf(__14) + " " + $"(already has {num} body/bodies)"));
				Guard.Report(__14, "SpawnPlayer", Verdict.Certain("clone-spawn", $"tried to spawn another copy of themselves - they already have {num}"));
				return false;
			}
			Resolve();
			List<string> list = new List<string>();
			Check("hat", __10, CountOf(_hats), list);
			Check("outfit", __11, CountOf(_outfits), list);
			Check("accessory", __12, CountOf(_accessories), list);
			if (list.Count == 0)
			{
				return true;
			}
			string text = Sender.NameOf(__14);
			string text2 = "sent a spawn that would crash everyone else in the lobby (" + string.Join(", ", list) + ")";
			Plugin.Log.LogError((object)("[Fishwarden] BLOCKED LOBBY CRASH from " + text + ": " + text2));
			Guard.Report(__14, "SpawnPlayer", Verdict.Certain("lobby-crash", text2));
			return false;
		}

		private static int BodiesFor(NetworkConnection conn)
		{
			if (conn == (NetworkConnection)null)
			{
				return 0;
			}
			int num = 0;
			try
			{
				foreach (Player player in PlayerManager.Players)
				{
					if (!((Object)(object)player == (Object)null) && !((NetworkBehaviour)player).IsDeinitializing && ((NetworkBehaviour)player).Owner == conn)
					{
						num++;
					}
				}
				return num;
			}
			catch
			{
				return 0;
			}
		}

		private static void Check(string what, byte value, int count, List<string> bad)
		{
			if (count >= 0 && value >= count)
			{
				bad.Add($"{what} index {value} with only {count} available");
			}
		}
	}
	internal static class Dashboard
	{
		private sealed class Button
		{
			public string Label;

			public Func<string> Do;

			public bool Hot;
		}

		[CompilerGenerated]
		private static class <>O
		{
			public static WindowFunction <0>__Body;
		}

		private static Rect _window = new Rect(0f, 0f, 1420f, 800f);

		private static bool _placed;

		private static float _pulse;

		private static Vector2 _playerScroll;

		private static Vector2 _caseScroll;

		private static Vector2 _wardenScroll;

		private static ulong _selected;

		private static string _toast;

		private static float _toastUntil;

		private static CursorLockMode _prevLock;

		private static bool _prevVisible;

		private static GUISkin _skin;

		private static Texture2D _panelTex;

		private static Texture2D _rowTex;

		private static bool _fontApplied;

		private static Vector2 _dossierScroll;

		private static bool _showBanned;

		private static Vector2 _bannedScroll;

		private static Vector2 _summaryScroll;

		public static bool IsOpen { get; private set; }

		public static bool UsingNative { get; private set; }

		public static void Toggle()
		{
			if (IsOpen)
			{
				Close();
			}
			else
			{
				Open();
			}
		}

		public static void Open()
		{
			//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)
			if (!IsOpen)
			{
				IsOpen = true;
				UsingNative = Plugin.NativeConsole.Value && NativeConsole.Open();
				if (Plugin.NativeConsole.Value && !UsingNative)
				{
					Plugin.Log.LogInfo((object)("[Console] native UI unavailable (" + NativeUI.Problem + "), using the drawn one."));
				}
				_prevLock = Cursor.lockState;
				_prevVisible = Cursor.visible;
				if (!_placed)
				{
					((Rect)(ref _window)).width = Mathf.Min(((Rect)(ref _window)).width, (float)(Screen.width - 40));
					((Rect)(ref _window)).height = Mathf.Min(((Rect)(ref _window)).height, (float)(Screen.height - 60));
					((Rect)(ref _window)).x = ((float)Screen.width - ((Rect)(ref _window)).width) / 2f;
					((Rect)(ref _window)).y = ((float)Screen.height - ((Rect)(ref _window)).height) / 2f;
					_placed = true;
				}
			}
		}

		public static void Close()
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			if (IsOpen)
			{
				IsOpen = false;
				NativeConsole.Close();
				UsingNative = false;
				Cursor.lockState = _prevLock;
				Cursor.visible = _prevVisible;
			}
		}

		public static void Tick()
		{
			NativeLook.SampleMenu();
			if (IsOpen)
			{
				Cursor.lockState = (CursorLockMode)0;
				Cursor.visible = true;
				if (UsingNative)
				{
					NativeConsole.Tick();
				}
			}
		}

		public static void BlockInputs_Post(Player __instance, ref bool __result)
		{
			if (!IsOpen | __result)
			{
				return;
			}
			try
			{
				if ((Object)(object)__instance == (Object)(object)Player.LocalPlayer)
				{
					__result = true;
				}
			}
			catch
			{
			}
		}

		private static Texture2D Solid(Color c)
		{
			//IL_0002: 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_000a: 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_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			Texture2D val = new Texture2D(1, 1);
			val.SetPixel(0, 0, c);
			val.Apply();
			((Object)val).hideFlags = (HideFlags)61;
			return val;
		}

		private static void BuildSkin()
		{
			//IL_0052: 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_00e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Expected O, but got Unknown
			//IL_0102: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Expected O, but got Unknown
			//IL_011b: 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)
			//IL_01ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f7: Expected O, but got Unknown
			//IL_01fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_020d: Unknown result type (might be due to invalid IL or missing references)
			//IL_021c: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_skin != (Object)null && (_fontApplied || (Object)(object)NativeLook.Font == (Object)null))
			{
				return;
			}
			if ((Object)(object)_skin != (Object)null && (Object)(object)NativeLook.Font != (Object)null)
			{
				_skin.font = NativeLook.Font;
				_fontApplied = true;
				return;
			}
			_panelTex = Theme.Solid(Theme.Panel);
			_rowTex = Theme.Solid(Theme.Card);
			_skin = Object.Instantiate<GUISkin>(GUI.skin);
			((Object)_skin).hideFlags = (HideFlags)61;
			Font font = NativeLook.Font;
			if ((Object)(object)font != (Object)null)
			{
				_skin.font = font;
			}
			_skin.window.normal.background = _panelTex;
			_skin.window.onNormal.background = _panelTex;
			_skin.window.border = new RectOffset(8, 8, 24, 8);
			_skin.window.padding = new RectOffset(16, 16, 32, 14);
			_skin.window.normal.textColor = NativeLook.MenuText;
			_skin.window.fontSize = NativeLook.MenuSize + 2;
			_skin.window.fontStyle = (FontStyle)1;
			_skin.label.normal.textColor = NativeLook.MenuText;
			_skin.label.fontSize = NativeLook.MenuSize;
			_skin.label.fontStyle = (FontStyle)(NativeLook.MenuBold ? 1 : 0);
			_skin.label.wordWrap = false;
			GUIStyle[] array = (GUIStyle[])(object)new GUIStyle[2] { _skin.button, _skin.box };
			foreach (GUIStyle obj in array)
			{
				obj.fontSize = NativeLook.MenuSize;
				obj.fontStyle = (FontStyle)(NativeLook.MenuBold ? 1 : 0);
				obj.padding = new RectOffset(10, 10, 6, 6);
				obj.normal.textColor = Color.white;
				obj.hover.textColor = Color.white;
				obj.active.textColor = Color.white;
			}
			_skin.box.normal.background = _rowTex;
			_skin.scrollView.normal.background = _rowTex;
		}

		public static void Draw()
		{
			//IL_001a: 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_0049: 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_0090: 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_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Expected O, but got Unknown
			if (IsOpen && !UsingNative)
			{
				BuildSkin();
				GUISkin skin = GUI.skin;
				Color color = GUI.color;
				GUI.skin = _skin;
				GUI.color = Color.white;
				GUI.DrawTexture(new Rect(0f, 0f, (float)Screen.width, (float)Screen.height), (Texture)(object)Solid(new Color(0f, 0f, 0f, 0.45f)));
				_pulse = Mathf.PingPong(Time.realtimeSinceStartup * 1.6f, 1f);
				Rect window = _window;
				object obj = <>O.<0>__Body;
				if (obj == null)
				{
					WindowFunction val = Body;
					<>O.<0>__Body = val;
					obj = (object)val;
				}
				_window = GUI.Window(7957, window, (WindowFunction)obj, "Fish Warden".ToUpperInvariant() + "   —   F4 closes   ·   look and movement are locked");
				GUI.skin = skin;
				GUI.color = color;
			}
		}

		private static void Body(int id)
		{
			//IL_0098: 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_00bd: 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_016d: 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_01af: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c3: Unknown result type (might be due to invalid IL or missing references)
			GUILayout.Space(4f);
			Banner();
			ModeBar();
			PresetBar();
			NoisyBar();
			Divider();
			if (!Plugin.IsHosting)
			{
				GUILayout.Label("You are a guest in someone else's lobby. Nothing here can be enforced from your machine.", Array.Empty<GUILayoutOption>());
				GUILayout.Label(ClientWatch.Readout(), Array.Empty<GUILayoutOption>());
				GUI.DragWindow(new Rect(0f, 0f, 10000f, 22f));
				return;
			}
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			GUILayout.BeginVertical(GUIStyle.op_Implicit("box"), (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(880f) });
			Theme.Line("WARDEN", Theme.Accent, 15);
			GUILayout.Space(2f);
			_wardenScroll = GUILayout.BeginScrollView(_wardenScroll, Array.Empty<GUILayoutOption>());
			if (Cases.PendingCount > 0)
			{
				CaseList();
				Divider();
			}
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			PlayerList();
			GUILayout.Space(10f);
			ActionColumn();
			GUILayout.EndHorizontal();
			Divider();
			if (_showBanned)
			{
				BannedPanel();
			}
			else
			{
				SummaryPanel();
			}
			Divider();
			ToolBar();
			Divider();
			GuardSettings.Draw();
			GUILayout.EndScrollView();
			GUILayout.EndVertical();
			GUILayout.Space(14f);
			VerticalRule();
			GUILayout.Space(14f);
			GUILayout.BeginVertical(GUIStyle.op_Implicit("box"), (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(460f) });
			Theme.Line("ENDER'S TWEAKS", Theme.Accent, 15);
			GUILayout.Space(4f);
			Tweaks.Draw();
			GUILayout.EndVertical();
			GUILayout.EndHorizontal();
			if (_toast != null && Time.realtimeSinceStartup < _toastUntil)
			{
				GUILayout.Space(4f);
				Color color = GUI.color;
				GUI.color = new Color(0.6f, 0.9f, 0.7f);
				GUILayout.Label(_toast, Array.Empty<GUILayoutOption>());
				GUI.color = color;
			}
			GUI.DragWindow(new Rect(0f, 0f, 10000f, 22f));
		}

		private static void Banner()
		{
			//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_0079: 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_009a: 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_00bb: 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)
			//IL_00e7: 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_011a: 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_0159: Unknown result type (might be due to invalid IL or missing references)
			//IL_0152: Unknown result type (might be due to invalid IL or missing references)
			if (Plugin.IsHosting)
			{
				Dictionary<ulong, int> dictionary = Logbook.Tally();
				int count = dictionary.Count;
				int num = dictionary.Keys.Count((ulong k) => Summary.ProvenCount(k) > 0);
				GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
				Theme.Stat(Cases.PendingCount.ToString(), "waiting on you", (Cases.PendingCount > 0) ? Color.Lerp(Theme.Urgent, Theme.Bad, _pulse) : Theme.Muted);
				Theme.Stat(count.ToString(), "flagged", (count > 0) ? Theme.Warn : Theme.Good);
				Theme.Stat(num.ToString(), "proven", (num > 0) ? Theme.Bad : Theme.Good);
				Theme.Stat(Troll.Count.ToString(), "being trolled", (Troll.Count > 0) ? Theme.Accent : Theme.Muted);
				GUILayout.FlexibleSpace();
				GUILayout.BeginVertical(Array.Empty<GUILayoutOption>());
				GUILayout.Space(6f);
				string text = Actions.Status();
				if (text.Length > 0)
				{
					Theme.Pill(text, Theme.Bad);
				}
				string text2 = Extras.Status();
				if (text2.Length > 0)
				{
					Theme.Pill(text2, Theme.Warn);
				}
				string text3 = Safety.Status();
				if (text3 != null)
				{
					Theme.Pill(text3, Safety.Tripped ? Theme.Bad : Theme.Warn);
				}
				GUILayout.EndVertical();
				GUILayout.EndHorizontal();
				Theme.Rule();
			}
		}

		private static void VerticalRule()
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//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_0031: 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)
			Rect rect = GUILayoutUtility.GetRect(1f, 1f, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.Width(1f),
				GUILayout.ExpandHeight(true)
			});
			Color color = GUI.color;
			GUI.color = Theme.Divide;
			GUI.DrawTexture(rect, (Texture)(object)Texture2D.whiteTexture);
			GUI.color = color;
		}

		private static void Divider()
		{
			//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_002d: 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_0056: Unknown result type (might be due to invalid IL or missing references)
			GUILayout.Space(6f);
			Rect rect = GUILayoutUtility.GetRect(1f, 1f, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.ExpandWidth(true) });
			Color color = GUI.color;
			GUI.color = new Color(1f, 1f, 1f, 0.18f);
			GUI.DrawTexture(rect, (Texture)(object)Texture2D.whiteTexture);
			GUI.color = color;
			GUILayout.Space(6f);
		}

		private static void ModeBar()
		{
			//IL_0128: 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_0140: Unknown result type (might be due to invalid IL or missing references)
			//IL_019e: Unknown result type (might be due to invalid IL or missing references)
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			GUILayout.Label("Level:", (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(44f) });
			LevelButton(Level.Watch);
			LevelButton(Level.Block);
			LevelButton(Level.Strict);
			LevelButton(Level.Lockdown);
			GUILayout.Space(16f);
			bool value = Plugin.AutoKick.Value;
			if (GUILayout.Button(value ? "Auto-remove: ON" : "Auto-remove: ask me first", (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(210f) }))
			{
				Plugin.AutoKick.Value = !value;
				Toast(Plugin.AutoKick.Value ? "Auto-remove on - people are removed the moment they cross the line." : "Auto-remove off - you will be asked first.");
			}
			GUILayout.Space(8f);
			if (GUILayout.Button(Plugin.Quiet.Value ? "Quiet: ON" : "Quiet: off", (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(110f) }))
			{
				Plugin.Quiet.Value = !Plugin.Quiet.Value;
				Toast(Plugin.Quiet.Value ? "Quiet on - cheats just fail, with nothing telling them why." : "Quiet off - proven findings are announced in chat.");
			}
			GUILayout.Space(8f);
			AutoTroll.Trigger mode = AutoTroll.Mode;
			Color backgroundColor = GUI.backgroundColor;
			if (mode != AutoTroll.Trigger.Off)
			{
				GUI.backgroundColor = new Color(0.35f, 0.65f, 0.85f);
			}
			if (GUILayout.Button("Auto-troll: " + ((mode == AutoTroll.Trigger.Off) ? "off" : mode.ToString()), (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(180f) }))
			{
				AutoTroll.SetMode((mode != AutoTroll.Trigger.ChosenRules) ? (mode + 1) : AutoTroll.Trigger.Off);
				Toast(AutoTroll.Summary());
			}
			GUI.backgroundColor = backgroundColor;
			GUILayout.FlexibleSpace();
			if (!Catalogue.Usable)
			{
				GUILayout.Label("shop list unavailable", Array.Empty<GUILayoutOption>());
			}
			string text = Safety.Status();
			if (text != null)
			{
				GUILayout.Label(text, Array.Empty<GUILayoutOption>());
			}
			else
			{
				GUILayout.Label(TackleCheck.Passed ? $"{Plugin.Armed} guards on" : "NOT WORKING", Array.Empty<GUILayoutOption>());
			}
			GUILayout.EndHorizontal();
		}

		private static void LevelButton(Level l)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: 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)
			bool num = Plugin.CurrentLevel == l;
			Color backgroundColor = GUI.backgroundColor;
			if (num)
			{
				GUI.backgroundColor = new Color(0.35f, 0.75f, 0.95f);
			}
			string text = Policy.Name(l);
			if (GUILayout.Button(num ? ("[" + text + "]") : text, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(92f) }))
			{
				Plugin.SetLevel(l);
				Toast(Policy.Explain(l));
			}
			GUI.backgroundColor = backgroundColor;
		}

		private static void PresetBar()
		{
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			GUILayout.Label("Set up for:", (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(76f) });
			Presets.Preset[] all = Presets.All;
			foreach (Presets.Preset preset in all)
			{
				if (GUILayout.Button(preset.Name, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(24f) }))
				{
					Toast(Presets.Apply(preset));
				}
			}
			GUILayout.EndHorizontal();
			Color color = GUI.color;
			GUI.color = new Color(1f, 1f, 1f, 0.45f);
			GUILayout.Label("   " + Policy.Grid(Plugin.CurrentLevel) + ((Rules.DisabledCount > 0) ? ("      switched off: " + string.Join(", ", Rules.Disabled)) : ""), Array.Empty<GUILayoutOption>());
			GUI.color = color;
		}

		private static void NoisyBar()
		{
			//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_004e: 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)
			List<string> list = Cases.NoisyRules().ToList();
			if (list.Count == 0 && Rules.DisabledCount == 0)
			{
				return;
			}
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			foreach (string item in list)
			{
				Color color = GUI.color;
				GUI.color = new Color(1f, 0.8f, 0.4f);
				GUILayout.Label("'" + item + "' keeps misfiring", (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(220f) });
				GUI.color = color;
				if (GUILayout.Button("Stop checking it", (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(130f) }))
				{
					Toast(Rules.Disable(item) ? ("'" + item + "' switched off.") : ("'" + item + "' was already off."));
				}
			}
			foreach (string item2 in Rules.Disabled.ToList())
			{
				if (GUILayout.Button("Re-enable '" + item2 + "'", (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(160f) }))
				{
					Toast(Rules.Enable(item2) ? ("'" + item2 + "' switched back on.") : "");
				}
			}
			GUILayout.EndHorizontal();
		}

		private static void CaseList()
		{
			//IL_0000: 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)
			//IL_0041: 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)
			Color color = GUI.color;
			GUI.color = new Color(1f, 0.82f, 0.35f);
			GUILayout.Label($"WAITING ON YOU  ({Cases.PendingCount})", Array.Empty<GUILayoutOption>());
			GUI.color = color;
			_caseScroll = GUILayout.BeginScrollView(_caseScroll, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height((float)Mathf.Min(140, 34 + Cases.PendingCount * 46)) });
			foreach (Cases.Case item in Cases.Open.ToList())
			{
				GUILayout.BeginHorizontal(GUIStyle.op_Implicit("box"), Array.Empty<GUILayoutOption>());
				GUILayout.BeginVertical(Array.Empty<GUILayoutOption>());
				GUILayout.Label(string.Format("{0}   {1} strikes   {2}", item.Name, item.Strikes, item.Proven ? "PROVEN" : "judgement call"), Array.Empty<GUILayoutOption>());
				GUILayout.Label("   " + string.Join(", ", item.Rules), Array.Empty<GUILayoutOption>());
				GUILayout.EndVertical();
				GUILayout.FlexibleSpace();
				if (GUILayout.Button("Remove them", (GUILayoutOption[])(object)new GUILayoutOption[2]
				{
					GUILayout.Width(120f),
					GUILayout.Height(38f)
				}))
				{
					Toast(Cases.Accept(item.Id));
				}
				if (GUILayout.Button("They're fine", (GUILayoutOption[])(object)new GUILayoutOption[2]
				{
					GUILayout.Width(120f),
					GUILayout.Height(38f)
				}))
				{
					Toast(Cases.Dismiss(item.Id));
				}
				GUILayout.EndHorizontal();
			}
			GUILayout.EndScrollView();
		}

		private static void PlayerList()
		{
			//IL_0027: 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_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0127: Unknown result type (might be due to invalid IL or missing references)
			//IL_012c: 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)
			//IL_016a: Unknown result type (might be due to invalid IL or missing references)
			//IL_018a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0245: Unknown result type (might be due to invalid IL or missing references)
			GUILayout.BeginVertical((GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(440f) });
			GUILayout.Label("PLAYERS  —  click one to act on them", Array.Empty<GUILayoutOption>());
			_playerScroll = GUILayout.BeginScrollView(_playerScroll, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(240f) });
			List<Player> list = Others();
			if (list.Count == 0)
			{
				GUILayout.Label("   nobody else in the lobby", Array.Empty<GUILayoutOption>());
			}
			Dictionary<ulong, int> dictionary = new Dictionary<ulong, int>();
			foreach (Player item in list)
			{
				try
				{
					dictionary[item.SteamID] = ((!dictionary.TryGetValue(item.SteamID, out var value)) ? 1 : (value + 1));
				}
				catch
				{
				}
			}
			HashSet<ulong> hashSet = new HashSet<ulong>();
			foreach (Player item2 in list)
			{
				ulong steamID;
				try
				{
					steamID = item2.SteamID;
				}
				catch
				{
					continue;
				}
				if (hashSet.Add(steamID))
				{
					int value2;
					int num = (Logbook.Tally().TryGetValue(steamID, out value2) ? value2 : 0);
					string text = Tags(steamID, num);
					bool flag = _selected == steamID;
					Color backgroundColor = GUI.backgroundColor;
					if (flag)
					{
						GUI.backgroundColor = new Color(0.35f, 0.7f, 0.9f);
					}
					else if (num >= Plugin.KickThreshold.Value)
					{
						GUI.backgroundColor = new Color(0.9f, 0.45f, 0.4f);
					}
					else if (num > 0)
					{
						GUI.backgroundColor = new Color(0.9f, 0.75f, 0.4f);
					}
					int value3;
					int num2 = ((!dictionary.TryGetValue(steamID, out value3)) ? 1 : value3);
					string text2 = ((num2 > 1) ? $"{item2.SteamName} x{num2}" : item2.SteamName);
					if (GUILayout.Button(string.Format("{0}{1,-24}  {2,-12}  {3}", flag ? "> " : "  ", text2, (num > 0) ? (num + " strikes") : "clean", text), (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(26f) }))
					{
						_selected = (flag ? 0 : steamID);
					}
					GUI.backgroundColor = backgroundColor;
				}
			}
			GUILayout.EndScrollView();
			GUILayout.EndVertical();
		}

		private static void ActionColumn()
		{
			//IL_032f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0348: Unknown result type (might be due to invalid IL or missing references)
			GUILayout.BeginVertical((GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(420f) });
			Player p = Selected();
			if ((Object)(object)p == (Object)null)
			{
				GUILayout.Label("Nobody selected.", Array.Empty<GUILayoutOption>());
				GUILayout.Space(4f);
				GUILayout.Label("Click a player on the left to see", Array.Empty<GUILayoutOption>());
				GUILayout.Label("everything about them, and what you", Array.Empty<GUILayoutOption>());
				GUILayout.Label("can do about it.", Array.Empty<GUILayoutOption>());
				GUILayout.EndVertical();
				return;
			}
			Dossier(p);
			GUILayout.Space(8f);
			Group("STOP THEM RIGHT NOW");
			Row(Btn(Actions.IsFrozen(_selected) ? "Unfreeze" : "Freeze", () => Actions.ToggleFreeze(p)), Btn(Actions.IsMuted(_selected) ? "Unmute" : "Mute", () => Actions.ToggleMute(p)), Actions.IsMuted(_selected) ? Btn("Why: " + MuteLines.Name(Actions.ReasonFor(_selected)), () => Actions.CycleReason(p)) : null, Btn("Strip", () => Actions.Strip(p)), Btn("De-clone", () => Actions.Purge(p)));
			Group("MAKE IT NOT WORTH IT");
			Row(BtnHot(Troll.Is(_selected) ? "STOP TROLL" : "TROLL MODE", () => Troll.Toggle(p)), Btn(Extras.HasBlowback(_selected) ? "No blowback" : "Blow up", () => Extras.Blowback(p)), Btn(Extras.IsButterfingers(_selected) ? "Steady hands" : "Butterfingers", () => Extras.Butterfingers(p)));
			Row(Btn(Extras.IsSkunked(_selected) ? "Un-skunk" : "Skunk", () => Extras.Skunk(p)), Btn(Extras.InCooler(_selected) ? "Out of cooler" : "Cooler", () => Extras.Cool(p)), Btn("Out to sea", () => Extras.Locker(p)));
			Group("DECIDE");
			Row(BtnHot("REMOVE", delegate
			{
				int value;
				int strikes = (Logbook.Tally().TryGetValue(_selected, out value) ? value : 0);
				Guard.RemoveNow(((NetworkBehaviour)p).Owner, strikes, "removed by hand");
				string steamName = p.SteamName;
				_selected = 0uL;
				return steamName + " removed.";
			}), Rollback.HasDamage(_selected) ? Btn("Undo their damage", () => Rollback.Gut(_selected)) : null, Btn("Trust", delegate
			{
				Crew.Add(_selected);
				return p.SteamName + " is trusted.";
			}), Btn("Pardon", delegate
			{
				Logbook.Pardon(_selected);
				Rollback.Clear(_selected);
				Safety.Forget(_selected);
				Extras.Release(_selected);
				return p.SteamName + " pardoned.";
			}));
			if (!Rollback.HasDamage(_selected))
			{
				Color color = GUI.color;
				GUI.color = new Color(1f, 1f, 1f, 0.35f);
				GUILayout.Label("Nothing of theirs is in the world to undo.", Array.Empty<GUILayoutOption>());
				GUI.color = color;
			}
			GUILayout.EndVertical();
		}

		private static void Dossier(Player p)
		{
			//IL_000f: 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)
			//IL_0024: 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_010a: 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_0146: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a9: 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_01c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b4: 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_01a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0333: Unknown result type (might be due to invalid IL or missing references)
			//IL_0270: Unknown result type (might be due to invalid IL or missing references)
			//IL_025a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0244: Unknown result type (might be due to invalid IL or missing references)
			ulong num;
			try
			{
				num = p.SteamID;
			}
			catch
			{
				num = 0uL;
			}
			Color color = GUI.color;
			GUI.color = new Color(0.55f, 0.8f, 0.95f);
			GUILayout.Label(p.SteamName, Array.Empty<GUILayoutOption>());
			GUI.color = new Color(1f, 1f, 1f, 0.4f);
			GUILayout.Label("steam " + num, Array.Empty<GUILayoutOption>());
			List<KeyValuePair<string, Color>> list = TagList(num);
			if (list.Count > 0)
			{
				GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
				foreach (KeyValuePair<string, Color> item in list)
				{
					Theme.Pill(item.Key, item.Value);
				}
				GUILayout.FlexibleSpace();
				GUILayout.EndHorizontal();
			}
			int value;
			int num2 = (Logbook.Tally().TryGetValue(num, out value) ? value : 0);
			int num3 = Summary.AttemptCount(num);
			int num4 = Summary.ProvenCount(num);
			GUI.color = Theme.ForStrikes(num2, Plugin.KickThreshold.Value);
			GUILayout.Label((num2 == 0) ? "No strikes - nothing against them" : $"{num2} strikes  ·  {num3} attempt(s)  ·  {num4} proven", Array.Empty<GUILayoutOption>());
			GUI.color = color;
			List<string> list2 = Summary.LinesFor(num);
			List<string> list3 = Logbook.ShotsFor(num);
			int num5 = Flight.CorrectionsFor(p);
			if (list2.Count == 0 && list3.Count == 0 && num5 == 0)
			{
				GUI.color = new Color(0.55f, 0.87f, 0.66f);
				GUILayout.Label("Clean. Nothing recorded against them.", Array.Empty<GUILayoutOption>());
				GUI.color = color;
				return;
			}
			_dossierScroll = GUILayout.BeginScrollView(_dossierScroll, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(130f) });
			if (list2.Count > 0)
			{
				GUI.color = new Color(0.55f, 0.8f, 0.95f);
				GUILayout.Label("WHAT THEY HAVE TRIED", Array.Empty<GUILayoutOption>());
				foreach (string item2 in list2)
				{
					bool flag = item2.TrimStart().StartsWith("!");
					GUI.color = (item2.Contains("NONE STOPPED") ? new Color(1f, 0.5f, 0.5f) : (flag ? new Color(0.97f, 0.45f, 0.38f) : new Color(0.93f, 0.72f, 0.35f)));
					GUILayout.Label(item2, Array.Empty<GUILayoutOption>());
				}
			}
			if (num5 > 0)
			{
				GUI.color = new Color(0.93f, 0.72f, 0.35f);
				GUILayout.Label($"Put back on the ground {num5} time(s)", Array.Empty<GUILayoutOption>());
			}
			if (list3.Count > 0)
			{
				GUI.color = new Color(0.55f, 0.8f, 0.95f);
				GUILayout.Label($"EVIDENCE  ({list3.Count} screenshot(s))", Array.Empty<GUILayoutOption>());
				GUI.color = new Color(1f, 1f, 1f, 0.45f);
				foreach (string item3 in list3.Take(3))
				{
					GUILayout.Label("  " + item3, Array.Empty<GUILayoutOption>());
				}
				if (list3.Count > 3)
				{
					GUILayout.Label($"  ...and {list3.Count - 3} more", Array.Empty<GUILayoutOption>());
				}
			}
			GUI.color = color;
			GUILayout.EndScrollView();
		}

		private static Button Btn(string label, Func<string> act)
		{
			return new Button
			{
				Label = label,
				Do = act
			};
		}

		private static Button BtnHot(string label, Func<string> act)
		{
			return new Button
			{
				Label = label,
				Do = act,
				Hot = true
			};
		}

		private static void Group(string title)
		{
			//IL_000a: 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)
			GUILayout.Space(6f);
			Color color = GUI.color;
			GUI.color = new Color(0.55f, 0.8f, 0.95f);
			GUILayout.Label(title, Array.Empty<GUILayoutOption>());
			GUI.color = color;
		}

		private static void Row(params Button[] buttons)
		{
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: 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_0037: Unknown result type (might be due to invalid IL or missing references)
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			foreach (Button button in buttons)
			{
				if (button == null)
				{
					continue;
				}
				Color backgroundColor = GUI.backgroundColor;
				if (button.Hot)
				{
					GUI.backgroundColor = new Color(0.85f, 0.42f, 0.36f);
				}
				if (GUILayout.Button(button.Label, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(30f) }))
				{
					try
					{
						Toast(button.Do());
					}
					catch (Exception ex)
					{
						Toast("Failed: " + ex.Message);
					}
				}
				GUI.backgroundColor = backgroundColor;
			}
			GUILayout.EndHorizontal();
		}

		private static void BannedPanel()
		{
			//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_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: 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)
			//IL_0091: 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_0059: 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_011e: Unknown result type (might be due to invalid IL or missing references)
			//IL_016c: Unknown result type (might be due to invalid IL or missing references)
			Color color = GUI.color;
			GUI.color = new Color(0.55f, 0.8f, 0.95f);
			GUILayout.Label($"BANNED  ({Bans.Count})   -   these people cannot rejoin", Array.Empty<GUILayoutOption>());
			GUI.color = color;
			if (Bans.Count == 0)
			{
				GUI.color = new Color(0.55f, 0.87f, 0.66f);
				GUILayout.Label("Nobody is banned.", Array.Empty<GUILayoutOption>());
				GUI.color = color;
				return;
			}
			_bannedScroll = GUILayout.BeginScrollView(_bannedScroll, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(120f) });
			foreach (Bans.Record item in Bans.All.OrderByDescending((Bans.Record x) => x.When).ToList())
			{
				GUILayout.BeginHorizontal(GUIStyle.op_Implicit("box"), Array.Empty<GUILayoutOption>());
				GUILayout.BeginVertical(Array.Empty<GUILayoutOption>());
				GUILayout.Label(item.Name, Array.Empty<GUILayoutOption>());
				GUI.color = new Color(1f, 1f, 1f, 0.45f);
				GUILayout.Label("   " + item.Reason, Array.Empty<GUILayoutOption>());
				GUILayout.Label($"   banned {item.When:yyyy-MM-dd HH:mm}   ·   steam {item.SteamId}", Array.Empty<GUILayoutOption>());
				GUI.color = color;
				GUILayout.EndVertical();
				GUILayout.FlexibleSpace();
				if (GUILayout.Button("Let them back in", (GUILayoutOption[])(object)new GUILayoutOption[2]
				{
					GUILayout.Width(150f),
					GUILayout.Height(46f)
				}))
				{
					string name = item.Name;
					if (Bans.Remove(item.SteamId))
					{
						Logbook.Pardon(item.SteamId);
						Safety.Forget(item.SteamId);
						Extras.Release(item.SteamId);
						Toast(name + " can rejoin - ban lifted and strikes cleared.");
					}
				}
				GUILayout.EndHorizontal();
			}
			GUILayout.EndScrollView();
		}

		private static void SummaryPanel()
		{
			//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_0015: 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_003b: 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_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_012c: 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_00f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			Color color = GUI.color;
			GUI.color = new Color(0.55f, 0.8f, 0.95f);
			GUILayout.Label("WHAT PEOPLE ARE TRYING", Array.Empty<GUILayoutOption>());
			GUI.color = color;
			List<string> list = Summary.Lines();
			_summaryScroll = GUILayout.BeginScrollView(_summaryScroll, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(120f) });
			foreach (string item in list)
			{
				bool flag = item.TrimStart().StartsWith("!");
				GUI.color = (Color)((!item.StartsWith(" ") && !item.StartsWith("(")) ? Color.white : (flag ? new Color(0.97f, 0.45f, 0.38f) : (item.StartsWith("(") ? new Color(1f, 1f, 1f, 0.4f) : new Color(0.93f, 0.72f, 0.35f))));
				GUILayout.Label(item, Array.Empty<GUILayoutOption>());
			}
			GUI.color = color;
			GUILayout.EndScrollView();
		}

		private static void ToolBar()
		{
			//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_0026: 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_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: 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_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_0232: Unknown result type (might be due to invalid IL or missing references)
			//IL_0237: Unknown result type (might be due to invalid IL or missing references)
			//IL_024e: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bd: Unknown result type (might be due to invalid IL or missing references)
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			Color backgroundColor = GUI.backgroundColor;
			if (Actions.Lockdown)
			{
				GUI.backgroundColor = new Color(0.9f, 0.45f, 0.4f);
			}
			if (GUILayout.Button(Actions.Lockdown ? "LOCKED" : "Lock lobby", (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.Height(28f),
				GUILayout.Width(110f)
			}))
			{
				Toast(Actions.ToggleLockdown());
			}
			GUI.backgroundColor = backgroundColor;
			if (GUILayout.Button("Clear clones", (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.Height(28f),
				GUILayout.Width(110f)
			}))
			{
				Toast(Actions.PurgeAll());
			}
			Color backgroundColor2 = GUI.backgroundColor;
			GUI.backgroundColor = new Color(0.85f, 0.42f, 0.36f);
			if (GUILayout.Button("Undo the session", (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.Height(28f),
				GUILayout.Width(150f)
			}))
			{
				Toast(Rollback.RestoreWorld());
			}
			GUI.backgroundColor = backgroundColor2;
			if (GUILayout.Button(Extras.ChumOut ? "Remove the trap" : "Set flight trap", (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.Height(28f),
				GUILayout.Width(120f)
			}))
			{
				if (Extras.ChumOut)
				{
					Extras.ClearChum();
					Toast("Bait cleared.");
				}
				else
				{
					Toast(Extras.DropChum());
				}
			}
			GUILayout.Space(12f);
			if (GUILayout.Button("< Island", (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.Height(28f),
				GUILayout.Width(80f)
			}))
			{
				Toast(HostTools.Next(backwards: true));
			}
			if (GUILayout.Button("Island >", (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.Height(28f),
				GUILayout.Width(80f)
			}))
			{
				Toast(HostTools.Next(backwards: false));
			}
			if (GUILayout.Button(HostTools.Flying ? "Land" : "Fly", (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.Height(28f),
				GUILayout.Width(70f)
			}))
			{
				Toast(HostTools.ToggleFly());
			}
			GUILayout.EndHorizontal();
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			Color backgroundColor3 = GUI.backgroundColor;
			if (_showBanned)
			{
				GUI.backgroundColor = new Color(0.35f, 0.75f, 0.95f);
			}
			if (GUILayout.Button(_showBanned ? $"Hide banned ({Bans.Count})" : $"Banned ({Bans.Count})", (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.Height(26f),
				GUILayout.Width(130f)
			}))
			{
				_showBanned = !_showBanned;
			}
			GUI.backgroundColor = backgroundColor3;
			if (GUILayout.Button("Save report", (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.Height(26f),
				GUILayout.Width(110f)
			}))
			{
				Toast(SaveReport());
			}
			if (GUILayout.Button("Summary to chat", (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.Height(26f),
				GUILayout.Width(140f)
			}))
			{
				foreach (string item in Summary.Lines())
				{
					Chat.Info(item);
				}
				Toast("Summary posted.");
			}
			if (GUILayout.Button("Test the guard", (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.Height(26f),
				GUILayout.Width(130f)
			}))
			{
				Toast(string.Join("   |   ", SelfTest.Run()));
			}
			GUILayout.EndHorizontal();
		}

		private static List<Player> Others()
		{
			List<Player> list = new List<Player>();
			try
			{
				foreach (Player player in PlayerManager.Players)
				{
					if ((Object)(object)player != (Object)null && (Object)(object)player != (Object)(object)Player.LocalPlayer)
					{
						list.Add(player);
					}
				}
			}
			catch
			{
			}
			return list;
		}

		private static Player Selected()
		{
			if (_selected == 0L)
			{
				return null;
			}
			foreach (Player item in Others())
			{
				try
				{
					if (item.SteamID == _selected)
					{
						return item;
					}
				}
				catch
				{
				}
			}
			return null;
		}

		private static List<KeyValuePair<string, Color>> TagList(ulong id)
		{
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: 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_0067: 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_00db: 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_0115: 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_014f: Unknown result type (might be due to invalid IL or missing references)
			List<KeyValuePair<string, Color>> t = new List<KeyValuePair<string, Color>>();
			if (Cases.Open.Any((Cases.Case c) => c.Key == id))
			{
				Add("NEEDS YOU", Theme.Urgent);
			}
			if (Troll.Is(id))
			{
				Add(AutoTroll.WasAutomatic(id) ? "TROLLED (auto)" : "TROLLED", Theme.Accent);
			}
			if (Actions.IsFrozen(id))
			{
				Add("frozen", Theme.Accent);
			}
			if (Actions.IsMuted(id))
			{
				Add("muted", Theme.Muted);
			}
			if (Extras.HasBlowback(id))
			{
				Add("rigged", Theme.Warn);
			}
			if (Extras.IsButterfingers(id))
			{
				Add("butterfingers", Theme.Warn);
			}
			if (Extras.IsSkunked(id))
			{
				Add("skunked", Theme.Warn);
			}
			if (Extras.InCooler(id))
			{
				Add("cooler", Theme.Warn);
			}
			if (Bans.IsBanned(id))
			{
				Add("BANNED", Theme.Bad);
			}
			if (Crew.Has(id))
			{
				Add("trusted", Theme.Good);
			}
			return t;
			void Add(string k, Color c)
			{
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				t.Add(new KeyValuePair<string, Color>(k, c));
			}
		}

		private static string Tags(ulong id, int strikes)
		{
			List<string> list = new List<string>();
			if (Crew.Has(id))
			{
				list.Add("trusted");
			}
			if (Troll.Is(id))
			{
				list.Add("TROLLED");
			}
			if (Actions.IsFrozen(id))
			{
				list.Add("frozen");
			}
			if (Actions.IsMuted(id))
			{
				list.Add("muted");
			}
			if (Extras.HasBlowback(id))
			{
				list.Add("rigged to blow");
			}
			if (Extras.IsButterfingers(id))
			{
				list.Add("butterfingers");
			}
			if (Extras.IsSkunked(id))
			{
				list.Add("skunked");
			}
			if (Extras.InCooler(id))
			{
				list.Add("in the cooler");
			}
			if (Bans.IsBanned(id))
			{
				list.Add("banned");
			}
			if (Cases.Open.Any((Cases.Case c) => c.Key == id))
			{
				list.Add("WAITING ON YOU");
			}
			return string.Join(", ", list);
		}

		private static string SaveReport()
		{
			try
			{
				Directory.CreateDirectory(Logbook.Folder);
				string text = Path.Combine(Logbook.Folder, "report_" + DateTime.Now.ToString("yyyy-MM-dd_HHmmss") + ".txt");
				File.WriteAllText(text, Logbook.Report());
				return "Report saved to " + text;
			}
			catch (Exception ex)
			{
				return "Could not save: " + ex.Message;
			}
		}

		internal static void Toast(string msg)
		{
			_toast = msg;
			_toastUntil = Time.realtimeSinceStartup + 6f;
			Plugin.Log.LogInfo((object)("[Dashboard] " + msg));
		}
	}
	internal static class Evidence
	{
		private static float _lastShot = -999f;

		private static int _sessionCount;

		public static int SessionCount => _sessionCount;

		public static string Folder => Path.Combine(Logbook.Folder, "evidence");

		public static bool Ready
		{
			get
			{
				if (Plugin.CaptureEvidence.Value && _sessionCount < Plugin.EvidenceSessionCap.Value)
				{
					return Time.realtimeSinceStartup - _lastShot >= Plugin.EvidenceCooldown.Value;
				}
				return false;
			}
		}

		public static void Capture(Entry entry)
		{
			if (!Ready || entry == null)
			{
				return;
			}
			_lastShot = Time.realtimeSinceStartup;
			_sessionCount++;
			string fileName = FileName(entry);
			try
			{
				((MonoBehaviour)Plugin.Instance).StartCoroutine(Grab(fileName, entry));
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("[Evidence] could not start capture: " + ex.Message));
			}
		}

		private static IEnumerator Grab(string fileName, Entry entry)
		{
			yield return (object)new WaitForEndOfFrame();
			Texture2D val = null;
			try
			{
				val = ScreenCapture.CaptureScreenshotAsTexture();
				byte[] array = ImageConversion.EncodeToPNG(val);
				Directory.CreateDirectory(Folder);
				File.WriteAllBytes(Path.Combine(Folder, fileName), array);
				Logbook.AttachShot(entry, fileName);
				Plugin.Log.LogInfo((object)$"[Evidence] captured {fileName} ({array.Length / 1024} KB)");
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("[Evidence] capture failed: " + ex.Message));
			}
			finally
			{
				if ((Object)(object)val != (Object)null)
				{
					Object.Destroy((Object)(object)val);
				}
			}
		}

		private static string FileName(Entry e)
		{
			string text = e.When.ToString("yyyy-MM-dd_HHmmss", CultureInfo.InvariantCulture);
			return text + "_" + Safe(e.Who) + "_" + Safe(e.Verdict.Rule) + ".png";
		}

		private static string Safe(string s)
		{
			if (string.IsNullOrEmpty(s))
			{
				return "unknown";
			}
			s = Regex.Replace(s, "<.*?>", "");
			s = Regex.Replace(s, "[^A-Za-z0-9_-]", "");
			if (s.Length == 0)
			{
				return "unknown";
			}
			if (s.Length <= 24)
			{
				return s;
			}
			return s.Substring(0, 24);
		}
	}
	internal static class Extras
	{
		private static Item _chum;

		private static Vector3 _chumAt;

		private static readonly HashSet<ulong> _skunked = new HashSet<ulong>();

		private static float _nextSkunkTick;

		private static readonly HashSet<Item> _alreadyZeroed = new HashSet<Item>();

		private static readonly Dictionary<ulong, float> _cooler = new Dictionary<ulong, float>();

		private static readonly HashSet<ulong> _blowback = new HashSet<ulong>();

		private static readonly Dictionary<ulong, float> _butter = new Dictionary<ulong, float>();

		public static bool ChumOut => (Object)(object)_chum != (Object)null;

		public static int SkunkedCount => _skunked.Count;

		public static int CoolerCount => _cooler.Count;

		public static int BlowbackCount => _blowback.Count;

		public static string DropChum()
		{
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: 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_0097: 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_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			if (!Plugin.IsHosting)
			{
				return "Only the host can chum the water.";
			}
			ClearChum();
			try
			{
				Player localPlayer = Player.LocalPlayer;
				if ((Object)(object)localPlayer == (Object)null)
				{
					return "No local player.";
				}
				Item spawnable = GameInfo.GetSpawnable(Plugin.ChumItem.Value.Replace(" ", "").ToLowerInvariant());
				if ((Object)(object)spawnable == (Object)null)
				{
					return "No item called '" + Plugin.ChumItem.Value + "'.";
				}
				_chumAt = Body.Of(localPlayer) + Vector3.up * Plugin.ChumHeight.Value;
				Item val = Object.Instantiate<Item>(spawnable, _chumAt, Quaternion.identity);
				((NetworkBehaviour)Server.Instance).Spawn(((Component)val).gameObject, (NetworkConnection)null, default(Scene));
				_chum = val;
				Plugin.Log.LogInfo((object)$"[Chum] dropped {((Object)spawnable).name} at {_chumAt} ({Plugin.ChumHeight.Value}m up)");
				return $"Chum in the water: {((Object)spawnable).name}, {Plugin.ChumHeight.Value}m up. Anyone who reaches it flew.";
			}
			catch (Exception ex)
			{
				Plugin.Log.LogError((object)("[Chum] " + ex));
				return "Could not drop chum: " + ex.Message;
			}
		}

		public static void ClearChum()
		{
			if (!((Object)(object)_chum == (Object)null))
			{
				try
				{
					_chum.DestroyItem((byte)4, byte.MaxValue);
				}
				catch
				{
				}
				_chum = null;
			}
		}

		public static void TickChum()
		{
			if ((Object)(object)_chum == (Object)null || !Plugin.IsHosting)
			{
				return;
			}
			Player val = null;
			try
			{
				val = _chum.Holder;
			}
			catch
			{
				_chum = null;
				return;
			}
			if (!((Object)(object)val == (Object)null))
			{
				if ((Object)(object)val == (Object)(object)Player.LocalPlayer)
				{
					ClearChum();
					return;
				}
				NetworkConnection owner = ((NetworkBehaviour)val).Owner;
				_chum = null;
				Guard.Report(owner, "Chum", Verdict.Certain("chum", $"collected chum placed {Plugin.ChumHeight.Value}m in the air - unreachable without flight"));
			}
		}

		public static bool IsSkunked(ulong id)
		{
			return _skunked.Contains(id);
		}

		public static string Skunk(Player p)
		{
			if ((Object)(object)p == (Object)null)
			{
				return "Nobody by that name.";
			}
			_skunked.Add(p.SteamID);
			return p.SteamName + " is skunked - their catches are worth nothing.";
		}

		public static string Unskunk(Player p)
		{
			if ((Object)(object)p == (Object)null)
			{
				return "Nobody by that name.";
			}
			_skunked.Remove(p.SteamID);
			return p.SteamName + " can earn again.";
		}

		public static void TickSkunk()
		{
			if (_skunked.Count == 0 || !Plugin.IsHosting)
			{
				return;
			}
			float realtimeSinceStartup = Time.realtimeSinceStartup;
			if (realtimeSinceStartup < _nextSkunkTick)
			{
				return;
			}
			_nextSkunkTick = realtimeSinceStartup + 1f;
			if (_alreadyZeroed.Count > 256)
			{
				_alreadyZeroed.Clear();
			}
			try
			{
				foreach (Player player in PlayerManager.Players)
				{
					if ((Object)(object)player == (Object)null || (Object)(object)player == (Object)(object)Player.LocalPlayer || !_skunked.Contains(player.SteamID))
					{
						continue;
					}
					Item val = (((Object)(object)player.Holding != (Object)null) ? player.Holding.HeldItem : null);
					if (!((Object)(object)val == (Object)null) && !_alreadyZeroed.Contains(val))
					{
						_alreadyZeroed.Add(val);
						try
						{
							Server.Instance.SetItemMultiplier(val, 0f);
						}
						catch
						{
						}
					}
				}
			}
			catch
			{
			}
		}

		public static bool InCooler(ulong id)
		{
			return _cooler.ContainsKey(id);
		}

		public static string Cool(Player p)
		{
			if ((Object)(object)p == (Object)null)
			{
				return "Nobody by that name.";
			}
			_cooler[p.SteamID] = 0f;
			return p.SteamName + " is in the cooler until you let them out.";
		}

		public static string Uncool(Player p)
		{
			if ((Object)(object)p == (Object)null)
			{
				return "Nobody by that name.";
			}
			_cooler.Remove(p.SteamID);
			return p.SteamName + " is out of the cooler.";
		}

		public static void TickCooler()
		{
			//IL_0084: 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)
			if (_cooler.Count == 0 || !Plugin.IsHosting)
			{
				return;
			}
			float realtimeSinceStartup = Time.realtimeSinceStartup;
			try
			{
				foreach (Player player in PlayerManager.Players)
				{
					if (!((Object)(object)player == (Object)null) && !((Object)(object)player == (Object)(object)Player.LocalPlayer) && _cooler.TryGetValue(player.SteamID, out var value) && !(realtimeSinceStartup < value))
					{
						_cooler[player.SteamID] = realtimeSinceStartup + Plugin.CoolerInterval.Value;
						try
						{
							Server.Instance.HitPlayer(player, 99999, Vector3.zero, Vector3.zero, (byte)0, (Player)null);
						}
						catch
						{
						}
					}
				}
			}
			catch
			{
			}
		}

		public static bool HasBlowback(ulong id)
		{
			return _blowback.Contains(id);
		}

		public static string Blowback(Player p)
		{
			if ((Object)(object)p == (Object)null)
			{
				return "Nobody by that name.";
			}
			if (_blowback.Add(p.SteamID))
			{
				return p.SteamName + " will now blow up every time they attack.";
			}
			_blowback.Remove(p.SteamID);
			return p.SteamName + " can attack safely again.";
		}

		public static bool TryDetonate(Player p)
		{
			//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_004d: 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)
			if ((Object)(object)p == (Object)null || !Plugin.IsHosting)
			{
				return false;
			}
			ulong steamID;
			try
			{
				steamID = p.SteamID;
			}
			catch
			{
				return false;
			}
			if (!_blowback.Contains(steamID))
			{
				return false;
			}
			try
			{
				Vector3 val = Body.Of(p);
				int value = Plugin.BlowbackDamage.Value;
				Server.Instance.HitPlayer(p, value, Vector3.up * Plugin.BlowbackLaunch.Value, val, (byte)2, (Player)null);
				Plugin.Log.LogInfo((object)("[Blowback] " + p.SteamName + " detonated on their own attack."));
				return true;
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("[Blowback] failed: " + ex.Message));
				return false;
			}
		}

		public static bool IsButterfingers(ulong id)
		{
			return _butter.ContainsKey(id);
		}

		public static string Butterfingers(Player p)
		{
			if ((Object)(object)p == (Object)null)
			{
				return "Nobody by that name.";
			}
			if (_butter.ContainsKey(p.SteamID))
			{
				_butter.Remove(p.SteamID);
				return p.SteamName + " can hold things again.";
			}
			_butter[p.SteamID] = 0f;
			return p.SteamName + " keeps dropping everything they pick up.";
		}

		public static void TickButterfingers()
		{
			//IL_00ab: 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)
			if (_butter.Count == 0 || !Plugin.IsHosting)
			{
				return;
			}
			float realtimeSinceStartup = Time.realtimeSinceStartup;
			try
			{
				foreach (Player player in PlayerManager.Players)
				{
					if ((Object)(object)player == (Object)null || (Object)(object)player == (Object)(object)Player.LocalPlayer || !_butter.TryGetValue(player.SteamID, out var value) || realtimeSinceStartup < value)
					{
						continue;
					}
					_butter[player.SteamID] = realtimeSinceStartup + Plugin.ButterfingersInterval.Value;
					if (!((Object)(object)(((Object)(object)player.Holding != (Object)null) ? player.Holding.HeldItem : null) == (Object)null))
					{
						try
						{
							Server.Instance.DropAllItems(player, Body.Of(player), Quaternion.identity);
						}
						catch
						{
						}
					}
				}
			}
			catch
			{
			}
		}

		public static string Locker(Player p)
		{
			//IL_0034: 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_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_005c: 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)
			if ((Object)(object)p == (Object)null)
			{
				return "Nobody by that name.";
			}
			if (!Plugin.IsHosting)
			{
				return "Only the host can do that.";
			}
			try
			{
				Player localPlayer = Player.LocalPlayer;
				Vector3 val = (((Object)(object)localPlayer != (Object)null) ? Body.Of(localPlayer) : Vector3.zero) + new Vector3(Plugin.LockerDistance.Value, 0f, Plugin.LockerDistance.Value);
				Server.Instance.TeleportPlayer(p, val, 0f);
				return p.SteamName + " has been sent to Davy Jones' locker. It is a long swim back.";
			}
			catch (Exception ex)
			{
				return "Could not: " + ex.Message;
			}
		}

		public static void ApplyTrollEffects(ulong id)
		{
			_blowback.Add(id);
			_butter[id] = 0f;
			_skunked.Add(id);
		}

		public static void Release(ulong id)
		{
			_skunked.Remove(id);
			_cooler.Remove(id);
			_blowback.Remove(id);
			_butter.Remove(id);
			Actions.Release(id);
		}

		public static string Status()
		{
			List<string> list = new List<string>();
			if (ChumOut)
			{
				list.Add("chum out");
			}
			if (_skunked.Count > 0)
			{
				list.Add($"{_skunked.Count} skunked");
			}
			if (_cooler.Count > 0)
			{
				list.Add($"{_cooler.Count} in the cooler");
			}
			if (_blowback.Count > 0)
			{
				list.Add($"{_blowback.Count} rigged to blow");
			}
			if (_butter.Count > 0)
			{
				list.Add($"{_butter.Count} butterfingered");
			}
			if (Troll.Count > 0)
			{
				list.Add($"{Troll.Count} in troll mode");
			}
			string text = Actions.Status();
			if (text.Length > 0)
			{
				list.Add(text);
			}
			if (list.Count != 0)
			{
				return string.Join(", ", list);
			}
			return "";
		}
	}
	internal static class Firing
	{
		private sealed class Gun
		{
			public float LastShot = -999f;

			public int SinceReload;

			public int LastAmmo = -1;

			public int WeaponId;

			public int FastShots;

			public float LastFinding = -999f;
		}

		private static readonly Dictionary<ulong, Gun> _guns = new Dictionary<ulong, Gun>();

		private static Gun For(NetworkConnection conn)
		{
			ulong key = Sender.KeyOf(conn);
			if (!_guns.TryGetValue(key, out var value))
			{
				value = new Gun();
				_guns[key] = value;
			}
			return value;
		}

		public static Verdict Shot(NetworkConnection conn, Player shooter)
		{
			if (!Plugin.WatchFiring.Value)
			{
				return Verdict.Clean;
			}
			Gun gun = For(conn);
			float realtimeSinceStartup = Time.realtimeSinceStartup;
			Weapon val = HeldWeapon(shooter);
			int num = (((Object)(object)val != (Object)null) ? ((Object)val).GetInstanceID() : 0);
			if (num != gun.WeaponId)
			{
				gun.WeaponId = num;
				gun.SinceReload = 0;
				gun.LastAmmo = -1;
			}
			int num2 = AmmoOf(val);
			if (num2 >= 0)
			{
				if (gun.LastAmmo >= 0 && num2 > gun.LastAmmo)
				{
					gun.SinceReload = 0;
				}
				gun.LastAmmo = num2;
			}
			gun.SinceReload++;
			int num3 = MagSize(val);
			if (num3 > 0 && (float)gun.SinceReload > (float)num3 * Plugin.MagTolerance.Value)
			{
				if (Ready(gun, realtimeSinceStartup))
				{
					gun.LastFinding = realtimeSinceStartup;
					int sinceReload = gun.SinceReload;
					gun.SinceReload = 0;
					return Verdict.Certain("no-reload", $"fired {sinceReload} shots without reloading - the magazine holds {num3}" + ((num2 >= 0) ? $", and the weapon reports {num2} left" : ""));
				}
				return Verdict.Clean;
			}
			float num4 = realtimeSinceStartup - gun.LastShot;
			gun.LastShot = realtimeSinceStartup;
			float num5 = MinInterval(val);
			if (num5 <= 0f || num4 > num5)
			{
				gun.FastShots = 0;
				return Verdict.Clean;
			}
			gun.FastShots++;
			if (gun.FastShots < Plugin.FastShotsForProof.Value)
			{
				return Verdict.Clean;
			}
			if (!Ready(gun, realtimeSinceStartup))
			{
				return Verdict.Clean;
			}
			gun.LastFinding = realtimeSinceStartup;
			int fastShots = gun.FastShots;
			gun.FastShots = 0;
			return Verdict.Certain("auto-fire", $"{fastShots} shots faster than the weapon can cycle ({num4 * 1000f:0}ms apart, needs {num5 * 1000f:0}ms)");
		}

		public static void Reloaded(NetworkConnection conn)
		{
			Gun gun = For(conn);
			gun.SinceReload = 0;
			gun.FastShots = 0;
		}

		private static Weapon HeldWeapon(Player p)
		{
			try
			{
				Item val = (((Object)(object)p != (Object)null && (Object)(object)p.Holding != (Object)null) ? p.Holding.HeldItem : null);
				return ((Object)(object)val != (Object)null) ? val.Weapon : null;
			}
			catch
			{
				return null;
			}
		}

		private static int AmmoOf(Weapon w)
		{
			if ((Object)(object)w == (Object)null)
			{
				return -1;
			}
			try
			{
				Traverse val = Traverse.Create((object)w).Property("Ammo", (object[])null);
				if (val != null && val.PropertyExists())
				{
					return val.GetValue<int>();
				}
				Traverse val2 = Traverse.Create((object)w).Field("_ammo");
				if (val2 != null && val2.FieldExists())
				{
					return val2.GetValue<int>();
				}
			}
			catch
			{
			}
			return -1;
		}

		private static int MagSize(Weapon w)
		{
			if ((Object)(object)w == (Object)null)
			{
				return -1;
			}
			try
			{
				object value = Traverse.Create((object)w).Field("_attachments").GetValue();
				Attachments val = (Attachments)((value is Attachments) ? value : null);
				if ((Object)(object)val == (Object)null)
				{
					return -1;
				}
				int ammoPerMag = val.AmmoPerMag;
				return (ammoPerMag > 0) ? ammoPerMag : (-1);
			}
			catch
			{
				return -1;
			}
		}

		private static float MinInterval(Weapon w)
		{
			if ((Object)(object)w == (Object)null)
			{
				return -1f;
			}
			try
			{
				Traverse val = Traverse.Create((object)w).Field("_timeBetweenShots");
				if (val == null || !val.FieldExists())
				{
					return -1f;
				}
				float value = val.GetValue<float>();
				if (value <= 0f)
				{
					return -1f;
				}
				return value * Mathf.Clamp01(Plugin.FireRateTolerance.Value);
			}
			catch
			{
				return -1f;
			}
		}

		private static bool Ready(Gun g, float now)
		{
			return now - g.LastFinding >= Plugin.MovementFindingCooldown.Value;
		}

		public static void Reset()
		{
			_guns.Clear();
		}
	}
	internal static class Flight
	{
		private sealed class Track
		{
			public Vector3 LastGround;

			public bool HasGround;

			public float AirborneSince = -1f;

			public float OnWaterSince = -1f;

			public float WaterLow;

			public float WaterHigh;

			public float LastAction = -999f;

			public int Corrections;

			public Vector3 LastPos;

			public bool HasLast;

			public int Phased;

			public float LastPhaseFinding = -999f;
		}

		private static readonly Dictionary<Player, Track> _tracks = new Dictionary<Player, Track>();

		private static float _nextTick;

		private static bool _loggedFirst;

		private static bool _saidWater;

		public static void Tick()
		{
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			if (!Plugin.IsHosting || !Plugin.WatchMovement.Value)
			{
				return;
			}
			float realtimeSinceStartup = Time.realtimeSinceStartup;
			if (realtimeSinceStartup < _nextTick)
			{
				return;
			}
			_nextTick = realtimeSinceStartup + Plugin.MovementSampleInterval.Value;
			try
			{
				foreach (Player player in PlayerManager.Players)
				{
					if (!((Object)(object)player == (Object)null) && !((Object)(object)player == (Object)(object)Player.LocalPlayer))
					{
						if (!_loggedFirst)
						{
							_loggedFirst = true;
							Plugin.Log.LogInfo((object)"[Flight] watching movement directly from transforms.");
						}
						Sample(player, Body.Of(player));
					}
				}
			}
			catch
			{
			}
		}

		public static void Sample(Player p, Vector3 pos)
		{
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0178: Unknown result type (might be due to invalid IL or missing references)
			//IL_0179: 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_0189: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ca: 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_00b2: 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_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)p == (Object)null || !Plugin.IsHosting || !Plugin.WatchMovement.Value)
			{
				return;
			}
			NetworkConnection owner = ((NetworkBehaviour)p).Owner;
			if (Sender.IsTrusted(owner))
			{
				return;
			}
			if (!_tracks.TryGetValue(p, out var value))
			{
				value = new Track();
				_tracks[p] = value;
			}
			float realtimeSinceStartup = Time.realtimeSinceStartup;
			bool onBoat;
			try
			{
				PlayerMovement movement = p.Movement;
				if ((Object)(object)movement == (Object)null)
				{
					return;
				}
				onBoat = movement.OnBoat;
			}
			catch
			{
				return;
			}
			bool num = onBoat || StandingOnSomething(pos);
			bool flag = Swimming(p);
			if (Plugin.CheckNoclip.Value && value.HasLast && !onBoat)
			{
				Vector3 val = pos - value.LastPos;
				float magnitude = ((Vector3)(ref val)).magnitude;
				if (magnitude > Plugin.NoclipMinStep.Value && CrossedSolid(value.LastPos, pos, magnitude))
				{
					value.Phased++;
					if (value.Phased >= Plugin.NoclipCrossingsForFinding.Value && realtimeSinceStartup - value.LastPhaseFinding >= Plugin.MovementFindingCooldown.Value)
					{
						value.LastPhaseFinding = realtimeSinceStartup;
						int phased = value.Phased;
						value.Phased = 0;
						Guard.Report(owner, "Movement", Verdict.Certain("noclip", $"moved through solid geometry {phased} times"));
						if (Plugin.PutFlyersDown.Value && Plugin.CurrentLevel > Level.Watch)
						{
							PutDown(p, value, owner);
						}
					}
				}
			}
			value.LastPos = pos;
			value.HasLast = true;
			if (num)
			{
				value.LastGround = pos;
				value.HasGround = true;
				value.AirborneSince = -1f;
				value.OnWaterSince = -1f;
				return;
			}
			if (value.AirborneSince < 0f)
			{
				value.AirborneSince = realtimeSinceStartup;
			}
			float num2 = realtimeSinceStartup - value.AirborneSince;
			float num3 = HeightAboveWater(pos);
			if (num3 > Plugin.WaterWalkFloor.Value && num3 < Plugin.WaterWalkBand.Value)
			{
				if (value.OnWaterSince < 0f)
				{
					value.OnWaterSince = realtimeSinceStartup;
					value.WaterLow = num3;
					value.WaterHigh = num3;
				}
				if (num3 < value.WaterLow)
				{
					value.WaterLow = num3;
				}
				if (num3 > value.WaterHigh)
				{
					value.WaterHigh = num3;
				}
				float num4 = realtimeSinceStartup - value.OnWaterSince;
				float num5 = value.WaterHigh - value.WaterLow;
				if (num4 > Plugin.WaterWalkSeconds.Value && num5 <= Plugin.WaterWalkWobble.Value && realtimeSinceStartup - value.LastAction >= Plugin.FlightActionCooldown.Value)
				{
					value.LastAction = realtimeSinceStartup;
					value.Corrections++;
					Guard.Report(owner, "Movement", Verdict.Certain("walking-on-water", $"stood on the water for {num4:0.0}s, height steady within " + $"{num5:0.00}m - not swimming, not grounded, no boat"));
					if (Plugin.PutFlyersDown.Value && Plugin.CurrentLevel > Level.Watch)
					{
						PutDown(p, value, owner);
					}
					return;
				}
			}
			else
			{
				value.OnWaterSince = -1f;
			}
			bool num6 = num2 > Plugin.FlightSeconds.Value && !flag;
			bool flag2 = num3 > Plugin.MaxJumpHeight.Value;
			if (!num6 && !flag2)
			{
				return;
			}
			float num7 = (flag2 ? (Plugin.FlightActionCooldown.Value * 0.25f) : Plugin.FlightActionCooldown.Value);
			if (!(realtimeSinceStartup - value.LastAction < num7))
			{
				value.LastAction = realtimeSinceStartup;
				value.Corrections++;
				bool num8 = num2 > Plugin.FlightSeconds.Value * 2f || num3 > Plugin.MaxJumpHeight.Value * 2f;
				string detail = (flag2 ? $"{num3:0}m above the water with no boat (a jump reaches {Plugin.MaxJumpHeight.Value:0}m)" : $"airborne {num2:0.0}s with no boat");
				Verdict v = (num8 ? Verdict.Certain("flying", detail) : Verdict.Strong("flight", detail));
				Guard.Report(owner, "Movement", v);
				if (Plugin.PutFlyersDown.Value && Plugin.CurrentLevel > Level.Watch)
				{
					PutDown(p, value, owner);
				}
				if (value.Corrections == Plugin.CorrectionsBeforeProof.Value)
				{
					Guard.Report(owner, "Movement", Verdict.Certain("persistent-flight", $"put back on the ground {value.Corrections} times and still flying"));
				}
			}
		}

		private static void PutDown(Player p, Track t, NetworkConnection conn)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: 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_0017: 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_002c: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = (t.HasGround ? t.LastGround : GroundBeneath(p));
			if (val == Vector3.zero)
			{
				return;
			}
			try
			{
				Server.Instance.TeleportPlayer(p, val, 0f);
				Plugin.Log.LogInfo((object)("[Flight] put " + Sender.NameOf(conn) + " back on the ground " + $"(correction #{t.Corrections})"));
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("[Flight] could not put them down: " + ex.Message));
			}
		}

		private static bool CrossedSolid(Vector3 from, Vector3 to, float len)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: 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_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: 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)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: 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_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_005b: 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_0069: 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_007d: 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_0084: 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_008a: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				Vector3 val = (to - from) / len;
				float value = Plugin.NoclipPadding.Value;
				Vector3 val2 = from + val * value;
				float num = len - value * 2f;
				if (num <= 0f)
				{
					return false;
				}
				val2 += Vector3.up * Plugin.NoclipProbeHeight.Value;
				int value2 = Plugin.LineOfSightMask.Value;
				RaycastHit val3 = default(RaycastHit);
				if (!Physics.Raycast(val2, val, ref val3, num, value2, (QueryTriggerInteraction)1))
				{
					return false;
				}
				RaycastHit val4 = default(RaycastHit);
				if (!Physics.Raycast(val2 + val * num, -val, ref val4, num, value2, (QueryTriggerInteraction)1))
				{
					return false;
				}
				return num - ((RaycastHit)(ref val3)).distance - ((RaycastHit)(ref val4)).distance >= Plugin.NoclipMinThickness.Value;
			}
			catch
			{
				return false;
			}
		}

		private static bool StandingOnSomething(Vector3 pos)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//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_0015: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				return Physics.Raycast(pos + Vector3.up * 0.5f, Vector3.down, Plugin.GroundedProbe.Value, Plugin.LineOfSightMask.Value, (QueryTriggerInteraction)1);
			}
			catch
			{
				return true;
			}
		}

		private static Vector3 GroundBeneath(Player p)
		{
			//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_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_0078: 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_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_0058: 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_006f: 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_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_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)
			//IL_004e: 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)
			try
			{
				RaycastHit val = default(RaycastHit);
				if (Physics.Raycast(Body.Of(p) + Vector3.up, Vector3.down, ref val, Plugin.GroundProbeDistance.Value, Plugin.LineOfSightMask.Value, (QueryTriggerInteraction)1))
				{
					return ((RaycastHit)(ref val)).point + Vector3.up * 0.2f;
				}
				Vector3 val2 = Body.Of(p);
				return new Vector3(val2.x, WaterManager.WaterHeight + 0.5f, val2.z);
			}
			catch
			{
				return Vector3.zero;
			}
		}

		private static bool Swimming(Player p)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				Transform val = (((Object)(object)p != (Object)null) ? p.Transform : null);
				if ((Object)(object)val == (Object)null)
				{
					return false;
				}
				float y = val.position.y;
				float waterHeight = WaterManager.WaterHeight;
				if (!_saidWater)
				{
					_saidWater = true;
					Plugin.Log.LogInfo((object)($"[Flight] waterline is y={waterHeight:0.00}; a player is " + $"standing at y={y:0.00}. Swimming means below the " + "first. If everyone reads as swimming, that is why the airtime rule went quiet."));
				}
				return y <= waterHeight;
			}
			catch
			{
				return false;
			}
		}

		private static float HeightAboveWater(Vector3 pos)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				return pos.y - WaterManager.WaterHeight;
			}
			catch
			{
				return 0f;
			}
		}

		public static int CorrectionsFor(Player p)
		{
			if (!((Object)(object)p != (Object)null) || !_tracks.TryGetValue(p, out var value))
			{
				return 0;
			}
			return value.Corrections;
		}

		public static void Reset()
		{
			_tracks.Clear();
			_loggedFirst = false;
		}
	}
	internal static class Guard
	{
		private sealed class Bucket
		{
			public int Count;

			public float WindowStart;

			public float LastFinding = -999f;
		}

		private static Player _pendingSpawn;

		private static ulong _pendingSpawnKey;

		private static readonly HashSet<string> Attacks = new HashSet<string> { "teleport-crash", "bad-numbers", "lobby-crash", "clone-spawn" };

		private static readonly HashSet<string> Symptoms = new HashSet<string> { "crash-packet", "packet-flood" };

		private static readonly Dictionary<ulong, int> _symptoms = new Dictionary<ulong, int>();

		private static float _symptomWindow;

		private const int PatternNeeded = 8;

		private static bool _saying;

		private static int _mostPellets;

		private static readonly Dictionary<string, List<float>> _bursts = new Dictionary<string, List<float>>();

		private static readonly Dictionary<string, Bucket> _buckets = new Dictionary<string, Bucket>();

		public static void Reader_Pre(NetworkConnection __2)
		{
			Sender.Capture(__2);
		}

		public static void Reader_Post()
		{
			Sender.Clear();
		}

		public static bool Teleport_Pre(Player __0, Vector3 __1, float __2)
		{
			//IL_0010: 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_00a8: Unknown result type (might be due to invalid IL or missing references)
			NetworkConnection current = Sender.Current;
			if (Skip(current))
			{
				return true;
			}
			if (!Body.Sane(__1))
			{
				Plugin.Log.LogError((object)("[Fishwarden] BLOCKED CRASH TELEPORT from " + Sender.NameOf(current) + " - coordinates are not a place"));
				Report(current, "TeleportPlayer", Verdict.Certain("teleport-crash", "sent a teleport to coordinates no position can hold - this crashes everyone it is applied to"));
				return false;
			}
			Verdict clean = Verdict.Clean;
			string text = (((Object)(object)__0 != (Object)null) ? __0.SteamName : "(gone)");
			clean = ((!((Object)(object)__0 != (Object)null) || !(((NetworkBehaviour)__0).Owner != current)) ? Verdict.Certain("teleport-self", "teleported themselves to " + Fmt(__1) + " - no client can do this legitimately") : Verdict.Certain("teleport-other", "moved " + text + " to " + Fmt(__1) + " - sender is not that player"));
			return Apply(current, "TeleportPlayer", clean);
		}

		public static bool HitPlayer_Pre(Player __0, int __1, Vector3 __2, Vector3 __3, byte __4, Player __5)
		{
			NetworkConnection current = Sender.Current;
			if (Skip(current))
			{
				return true;
			}
			Verdict v = Verdict.Clean;
			string text = (((Object)(object)__0 != (Object)null) ? __0.SteamName : "(gone)");
			bool flag = OneShotOn();
			int ceiling;
			string what;
			float distance;
			float allowed;
			if ((Object)(object)__5 != (Object)null && ((NetworkBehaviour)__5).Owner != current)
			{
				v = Verdict.Certain("damage-spoof", $"claimed {__1} damage to {text} as {__5.SteamName}, who did not send it");
				Rollback.NoteKill(Sender.KeyOf(current), __0);
			}
			else if (!flag && Weapons.IsImpossible(__5, __1, Weapons.PlayerDamageScale(__0), out ceiling, out what))
			{
				v = Verdict.Certain("damage-above-weapon", $"{__1} damage to {text} using {what}, which cannot exceed {ceiling} against a player");
				Rollback.NoteKill(Sender.KeyOf(current), __0);
			}
			else if (Plugin.WatchReach.Value && Reach.TooFar(__5, __0, out distance, out allowed))
			{
				v = Verdict.Certain("hit-from-nowhere", $"hit {text} from {distance:0}m away, but their reach is {allowed:0}m");
				Plugin.Log.LogWarning((object)("[Reach] " + Sender.NameOf(current) + ": " + Reach.Explain(__5, __0, current)));
				Rollback.NoteKill(Sender.KeyOf(current), __0);
			}
			else if (!flag && __1 > Plugin.MaxPlausibleDamage.Value)
			{
				v = Verdict.Certain("damage-impossible", $"{__1} damage to {text} (absolute ceiling {Plugin.MaxPlausibleDamage.Value})");
				Rollback.NoteKill(Sender.KeyOf(current), __0);
			}
			return Apply(current, "HitPlayer", v);
		}

		public static bool BuyItem_Pre(byte __0, Player __1, Item __2, Vector3 __3, Quaternion __4, bool __5)
		{
			NetworkConnection current = Sender.Current;
			if (Skip(current))
			{
				return true;
			}
			Verdict v = Verdict.Clean;
			string text = ItemName(__0);
			Item val = Resolve(__0);
			if (__5)
			{
				v = Verdict.Certain("free-purchase", "spawned " + text + " with the purchase marked free");
			}
			else if (!Catalogue.Sells(__0))
			{
				v = Verdict.Certain("not-for-sale", "bought " + text + ", which no shop in the game sells");
			}
			else if ((Object)(object)val != (Object)null && HasCreature(val))
			{
				v = Verdict.Certain("bought-a-creature", "bought " + text + ", which is a creature and is not sold anywhere");
			}
			else if ((Object)(object)val != (Object)null && ItemCost(val) <= 0)
			{
				v = Verdict.Certain("bought-unpriced", "bought " + text + ", which has no price and is not shop stock");
			}
			else if ((Object)(object)__1 != (Object)null && ((NetworkBehaviour)__1).Owner != current)
			{
				v = Verdict.Certain("purchase-other", "bought " + text + " on behalf of " + __1.SteamName);
			}
			bool flag = Apply(current, "BuyItem", v);
			if (flag)
			{
				try
				{
					Plugin.Log.LogInfo((object)("[Shop] " + Sender.NameOf(current) + " bought " + text + (((Object)(object)val != (Object)null) ? $" for {ItemCost(val)}" : " (unknown item)") + (Catalogue.Usable ? "" : "  - CATALOGUE BLIND, not checked against stock")));
				}
				catch
				{
				}
			}
			if (flag && v.Confidence == Confidence.Certain)
			{
				_pendingSpawn = __1;
				_pendingSpawnKey = Sender.KeyOf(current);
			}
			return flag;
		}

		public static void BuyItem_Post()
		{
			Player pendingSpawn = _pendingSpawn;
			ulong pendingSpawnKey = _pendingSpawnKey;
			_pendingSpawn = null;
			if ((Object)(object)pendingSpawn == (Object)null)
			{
				return;
			}
			try
			{
				Item val = (((Object)(object)pendingSpawn.Holding != (Object)null) ? pendingSpawn.Holding.HeldItem : null);
				if ((Object)(object)val != (Object)null)
				{
					Rollback.NoteSpawn(pendingSpawnKey, val);
				}
			}
			catch
			{
			}
		}

		public static bool DropAllItems_Pre(Player __0, Vector3 __1, Quaternion __2)
		{
			NetworkConnection current = Sender.Current;
			if (Skip(current))
			{
				return true;
			}
			Verdict v = Verdict.Clean;
			if ((Object)(object)__0 != (Object)null && ((NetworkBehaviour)__0).Owner != current)
			{
				v = Verdict.Certain("force-drop", "forced " + __0.SteamName + " to drop everything they were carrying");
			}
			return Apply(current, "DropAllItems", v);
		}

		public static bool FinishGame_Pre()
		{
			NetworkConnection current = Sender.Current;
			if (Skip(current))
			{
				return true;
			}
			Verdict v = Verdict.Certain("force-finish", "tried to end the run for the whole lobby");
			return Apply(current, "SendFinishGame", v);
		}

		private static bool Skip(NetworkConnection conn)
		{
			if (!TackleCheck.Passed)
			{
				return true;
			}
			if (!Plugin.IsHosting)
			{
				return true;
			}
			return Sender.IsTrusted(conn);
		}

		private static bool Apply(NetworkConnection conn, string rpc, Verdict v)
		{
			if (!v.IsHostile)
			{
				return true;
			}
			if (!Rules.Enabled(v.Rule))
			{
				return true;
			}
			Action action = Policy.For(Plugin.CurrentLevel, v.Confidence);
			bool flag = Safety.HoldFire && v.Confidence != Confidence.Certain;
			if (flag)
			{
				action = Action.Log;
			}
			bool flag2 = action != Action.Log;
			Safety.Saw(Sender.KeyOf(conn), v.Confidence, v.Rule);
			ulong num = Sender.KeyOf(conn);
			string text = Sender.NameOf(conn);
			Rollback.NoteOffence(num);
			Summary.Note(num, text, v, flag2);
			AutoTroll.Consider(conn, num, text, v);
			Troll.Reacted(num, text, v.Rule);
			if (!Throttle.ShouldReport(num, text, v))
			{
				return !flag2;
			}
			Entry entry = Logbook.Record(conn, rpc, v, flag2);
			if (v.Confidence == Confidence.Certain)
			{
				Evidence.Capture(entry);
				if (!flag && Plugin.AnnounceFindings.Value && !Plugin.Quiet.Value)
				{
					Announce("[Fishwarden] " + text + " - " + v.Detail);
				}
			}
			if (flag2 || action == Action.Remove)
			{
				Response.Answer(conn, v.Rule);
			}
			if (Attack(v))
			{
				Repel(conn, v);
				return !flag2;
			}
			if (action == Action.Remove)
			{
				ConsiderRemoval(conn);
			}
			return !flag2;
		}

		public static void Report(NetworkConnection conn, string source, Verdict v)
		{
			if (v.IsHostile && Plugin.IsHosting && TackleCheck.Passed && !Sender.IsTrusted(conn))
			{
				Apply(conn, source, v);
			}
		}

		private static void Repel(NetworkConnection conn, Verdict v)
		{
			string text = Sender.NameOf(conn);
			Plugin.Log.LogError((object)("[Fishwarden] " + text + " tried to crash the lobby (" + v.Rule + "). Removing regardless of level - this is not a cheat, it is an attack on everyone here."));
			Announce("[Fishwarden] " + text + " tried to crash the lobby and has been removed.");
			try
			{
				if (Plugin.EnforceBans.Value)
				{
					Player val = Sender.PlayerFor(conn);
					if ((Object)(object)val != (Object)null)
					{
						Bans.Add(val.SteamID, text, "tried to crash the lobby (" + v.Rule + ")");
					}
				}
			}
			catch
			{
			}
			try
			{
				RemoveNow(conn, Logbook.StrikesFor(conn), "tried to crash the lobby");
			}
			catch (Exception ex)
			{
				Plugin.Log.LogError((object)("[Fishwarden] could not remove them: " + ex.Message));
			}
		}

		private static bool Attack(Verdict v)
		{
			if (v.Rule == null)
			{
				return false;
			}
			if (Attacks.Contains(v.Rule))
			{
				return true;
			}
			if (!Symptoms.Contains(v.Rule))
			{
				return false;
			}
			float realtimeSinceStartup = Time.realtimeSinceStartup;
			if (realtimeSinceStartup >= _symptomWindow)
			{
				_symptomWindow = realtimeSinceStartup + 60f;
				_symptoms.Clear();
			}
			ulong key = Sender.KeyOf(Sender.Current);
			_symptoms.TryGetValue(key, out var value);
			value++;
			_symptoms[key] = value;
			if (value < 8)
			{
				return false;
			}
			Plugin.Log.LogWarning((object)($"[Fishwarden] {value} of '{v.Rule}' from one player inside a " + "minute - that is a pattern rather than bad luck."));
			return true;
		}

		private static void ConsiderRemoval(NetworkConnection conn)
		{
			int num = Logbook.StrikesFor(conn);
			int value = Plugin.KickThreshold.Value;
			if (num >= value)
			{
				if (!Safety.MayRemove(Sender.KeyOf(conn)))
				{
					Plugin.Log.LogInfo((object)($"[Fishwarden] {Sender.NameOf(conn)} is at {num} strikes but " + "nothing is proven - not removing. Heuristics never kick on their own."));
				}
				else if (!Plugin.AutoKick.Value)
				{
					Cases.OpenCase(conn, num);
				}
				else
				{
					RemoveNow(conn, num, "threshold");
				}
			}
		}

		public static void RemoveNow(NetworkConnection conn, int strikes, string why)
		{
			string text = Sender.NameOf(conn);
			string text2 = $"Fishwarden: {strikes} strikes ({why})";
			string value = Plugin.AppealTo.Value;
			if (!string.IsNullOrWhiteSpace(value))
			{
				text2 = text2 + " - wrongly kicked? " + value;
			}
			try
			{
				Announce($"[Fishwarden] {text} removed - {strikes} strikes. Gone fishing.");
				if (Plugin.EnforceBans.Value)
				{
					Player val = Sender.PlayerFor(conn);
					if ((Object)(object)val != (Object)null)
					{
						try
						{
							Bans.Add(val.SteamID, text, text2);
						}
						catch
						{
						}
					}
				}
				if (Plugin.GutOnRemoval.Value)
				{
					string text3 = Rollback.Gut(Sender.KeyOf(conn));
					Plugin.Log.LogInfo((object)("[Fishwarden] " + text3));
					Announce("[Fishwarden] " + text3);
				}
				conn.Kick((KickReason)0, (LoggingType)3, text2);
				Plugin.Log.LogWarning((object)$"[Fishwarden] kicked {text} ({strikes} strikes)");
			}
			catch (Exception ex)
			{
				Plugin.Log.LogError((object)("[Fishwarden] kick failed: " + ex.Message));
			}
		}

		public static void Announce(string msg)
		{
			if (_saying)
			{
				return;
			}
			try
			{
				_saying = true;
				Chat.Broadcast(msg);
			}
			finally
			{
				_saying = false;
			}
		}

		internal static bool OneShotOn()
		{
			try
			{
				return ServerSettings.OneShotEnabled;
			}
			catch
			{
				return false;
			}
		}

		private static Item Resolve(byte id)
		{
			try
			{
				return GameInfo.IDToItem(id);
			}
			catch
			{
				return null;
			}
		}

		private static bool HasCreature(Item item)
		{
			try
			{
				return (Object)(object)item.Creature != (Object)null;
			}
			catch
			{
				return false;
			}
		}

		private static int ItemCost(Item item)
		{
			try
			{
				return item.Cost;
			}
			catch
			{
				return 1;
			}
		}

		private static string ItemName(byte id)
		{
			try
			{
				Item val = GameInfo.IDToItem(id);
				if ((Object)(object)val != (Object)null && !string.IsNullOrEmpty(((Object)val).name))
				{
					return ((Object)val).name.Replace("(Clone)", "").Trim();
				}
			}
			catch
			{
			}
			return "item #" + id;
		}

		private static string Fmt(Vector3 v)
		{
			//IL_0005: 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_001b: Unknown result type (might be due to invalid IL or missing references)
			return $"({v.x:0},{v.y:0},{v.z:0})";
		}

		private static bool Owns(NetworkConnection conn, Player p)
		{
			if ((Object)(object)p != (Object)null)
			{
				return ((NetworkBehaviour)p).Owner == conn;
			}
			return false;
		}

		private static string NameOf(Player p)
		{
			object obj;
			if (!((Object)(object)p == (Object)null))
			{
				obj = p.SteamName;
				if (obj == null)
				{
					return "?";
				}
			}
			else
			{
				obj = "(gone)";
			}
			return (string)obj;
		}

		public static bool SetItemMultiplier_Pre(Item __0, float __1)
		{
			NetworkConnection current = Sender.Current;
			if (Skip(current))
			{
				return true;
			}
			Worths.Saw(__1);
			Verdict v = Verdict.Clean;
			string text = Worths.Abusing(Sender.KeyOf(current), __0);
			if (text != null)
			{
				v = Verdict.Certain("worth-inflation", text + " - the kill bonus is paid once, on the thing you killed");
			}
			else if (__1 > Plugin.ImpossibleWorthMultiplier.Value)
			{
				v = Verdict.Certain("worth-inflation", $"set sell value to x{__1:0} on {ItemLabel(__0)} - nothing in the game pays " + $"more than x{Plugin.ImpossibleWorthMultiplier.Value:0}");
			}
			else if (__1 > Plugin.MaxWorthMultiplier.Value)
			{
				v = Verdict.Strong("worth-inflation", $"set sell value to x{__1:0.0} on {ItemLabel(__0)} (ordinary play tops out " + $"around x{Plugin.MaxWorthMultiplier.Value:0}, {Worths.Seen()})");
			}
			else if (__1 > Plugin.VanillaWorthCeiling.Value)
			{
				v = Verdict.Contextual("worth-nudge", $"set sell value to x{__1:0.0} on {ItemLabel(__0)}");
			}
			if (v.Confidence == Confidence.Certain && (Object)(object)__0 != (Object)null)
			{
				Rollback.NoteInflated(Sender.KeyOf(current), __0);
			}
			return Apply(current, "SetItemMultiplier", v);
		}

		private static Verdict BuyCheck(NetworkConnection conn, Player buyer, string what)
		{
			if ((Object)(object)buyer != (Object)null && !Owns(conn, buyer))
			{
				return Verdict.Certain("purchase-other", "bought " + what + " on behalf of " + NameOf(buyer));
			}
			return Limit(conn, "purchase", Plugin.PurchasesPerMinute.Value, "purchases (" + what + ")");
		}

		public static bool BuyBait_Pre(Player __0, byte __1, int __2)
		{
			return Guarded((NetworkConnection conn) => BuyCheck(conn, __0, "bait"), "BuyBait");
		}

		public static bool BuyBoatMotor_Pre(Player __0, byte __1, int __2)
		{
			return Guarded((NetworkConnection conn) => BuyCheck(conn, __0, "a boat motor"), "BuyBoatMotor");
		}

		public static bool BuyBoatRadar_Pre(Player __0, int __1)
		{
			return Guarded((NetworkConnection conn) => BuyCheck(conn, __0, "boat radar"), "BuyBoatRadar");
		}

		public static bool BuyAttachment_Pre(Weapon __0, byte __1)
		{
			return Guarded((NetworkConnection conn) => BuyCheck(conn, HolderOf((Component)(object)__0), "a weapon attachment"), "BuyAttachment");
		}

		public static bool BuyBulletUpgrade_Pre(Weapon __0)
		{
			return Guarded((NetworkConnection conn) => BuyCheck(conn, HolderOf((Component)(object)__0), "a bullet upgrade"), "BuyBulletUpgrade");
		}

		public static bool BuySharpnessUpgrade_Pre(Melee __0)
		{
			return Guarded((NetworkConnection conn) => BuyCheck(conn, HolderOf((Component)(object)__0), "a sharpness upgrade"), "BuySharpnessUpgrade");
		}

		public static bool SetItemHolder_Pre(Item __0, Player __1, Item __2)
		{
			return Guarded((NetworkConnection conn) => (Owns(conn, __1) || !((Object)(object)__1 != (Object)null)) ? Verdict.Clean : Verdict.Strong("item-move", "put " + ItemLabel(__0) + " into " + NameOf(__1) + "'s hands"), "SetItemHolder");
		}

		public static bool RemoveItemFromInventory_Pre(Player __0, Item __1)
		{
			return Guarded((NetworkConnection conn) => (Owns(conn, __0) || !((Object)(object)__0 != (Object)null)) ? Verdict.Clean : Verdict.Strong("inventory-take", "took " + ItemLabel(__1) + " out of " + NameOf(__0) + "'s inventory"), "RemoveItemFromInventory");
		}

		public static bool PutItemInInventory_Pre(Player __0, Item __1, byte __2)
		{
			return Guarded((NetworkConnection conn) => (Owns(conn, __0) || !((Object)(object)__0 != (Object)null)) ? Verdict.Clean : Verdict.Strong("inventory-push", "pushed " + ItemLabel(__1) + " into " + NameOf(__0) + "'s inventory"), "PutItemInInventory");
		}

		public static bool TakeItemFromNpc_Pre(Player __0, byte __1)
		{
			return Guarded((NetworkConnection conn) => (Owns(conn, __0) || !((Object)(object)__0 != (Object)null)) ? Verdict.Clean : Verdict.Strong("npc-take", "took an NPC item as " + NameOf(__0)), "TakeItemFromNpc");
		}

		public static bool UnlockPocket_Pre(Player __0, byte __1)
		{
			return Guarded((NetworkConnection conn) => (Owns(conn, __0) || !((Object)(object)__0 != (Object)null)) ? Verdict.Clean : Verdict.Strong("pocket-unlock", "unlocked a pocket as " + NameOf(__0)), "UnlockPocket");
		}

		public static bool ResurrectPlayer_Pre(Player __0, DeadPlayer __1)
		{
			return Guarded(delegate(NetworkConnection conn)
			{
				if (!Owns(conn, __0))
				{
					return Verdict.Clean;
				}
				int num = Burst(conn, "selfrevive", Plugin.SelfReviveWindow.Value);
				return (num <= 1) ? Verdict.Certain("self-revive", "resurrected themselves - the game cancels a revive if the reviver is dead") : Verdict.Certain("self-revive", $"resurrected themselves ({num} times in {Plugin.SelfReviveWindow.Value:0}s)");
			}, "ResurrectPlayer");
		}

		private static int Burst(NetworkConnection conn, string what, float window)
		{
			string key = (conn?.ClientId ?? (-1)) + ":" + what;
			float now = Time.realtimeSinceStartup;
			if (!_bursts.TryGetValue(key, out var value))
			{
				value = new List<float>();
				_bursts[key] = value;
			}
			value.Add(now);
			value.RemoveAll((float t) => now - t > window);
			return value.Count;
		}

		public static bool ReloadWeapon_Pre(Weapon __0)
		{
			return Guarded(delegate(NetworkConnection conn)
			{
				Firing.Reloaded(conn);
				Player val = HolderOf((Component)(object)__0);
				return (!((Object)(object)val != (Object)null) || Owns(conn, val)) ? Verdict.Clean : Verdict.Strong("reload-other", "reloaded " + NameOf(val) + "'s weapon");
			}, "ReloadWeapon");
		}

		public static bool ChangeBait_Pre(Player __0, byte __1)
		{
			return Guarded(delegate(NetworkConnection conn)
			{
				if ((Object)(object)__0 != (Object)null && !Owns(conn, __0))
				{
					return Verdict.Certain("bait-set-other", "changed " + NameOf(__0) + "'s bait");
				}
				if (__1 == 0)
				{
					return Verdict.Clean;
				}
				return (OwnedBait(__0, __1) == 0) ? Verdict.Certain("bait-not-owned", $"equipped bait #{__1} without owning any") : Verdict.Clean;
			}, "ChangeBait");
		}

		private static int OwnedBait(Player p, byte index)
		{
			if ((Object)(object)p == (Object)null || index == 0)
			{
				return -1;
			}
			try
			{
				PlayerInventory inventory = p.Inventory;
				if ((Object)(object)inventory == (Object)null)
				{
					return -1;
				}
				if (!(Traverse.Create((object)inventory).Field("_ownedBaits").GetValue() is IList list))
				{
					return -1;
				}
				int num = index - 1;
				if (num < 0 || num >= list.Count)
				{
					return -1;
				}
				return Convert.ToInt32(list[num]);
			}
			catch
			{
				return -1;
			}
		}

		public static bool HandOverItemSimulation_Pre(Item __0)
		{
			return Guarded(delegate(NetworkConnection conn)
			{
				Player val = (((Object)(object)__0 != (Object)null) ? __0.Holder : null);
				return ((Object)(object)val != (Object)null && !Owns(conn, val)) ? Verdict.Strong("physics-grab", "took physics control of " + ItemLabel(__0) + " while " + NameOf(val) + " was holding it") : Limit(conn, "handover", Plugin.HandoversPerMinute.Value, "physics handovers");
			}, "HandOverItemSimulation");
		}

		public static bool RespawnPlayer_Pre(Player __0, Vector3 __1, Quaternion __2)
		{
			//IL_000d: 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)
			return Guarded((NetworkConnection conn) => (Owns(conn, __0) || !((Object)(object)__0 != (Object)null)) ? Verdict.Clean : Verdict.Certain("respawn-other", $"respawned {NameOf(__0)} at ({__1.x:0},{__1.y:0},{__1.z:0}) - a teleport by another name"), "RespawnPlayer");
		}

		public static bool HitCreature_Pre(Creature __0, Player __1, int __2, Vector3 __3, Vector3 __4)
		{
			//IL_00d0: 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)
			NetworkConnection current = Sender.Current;
			if (Skip(current))
			{
				return true;
			}
			Verdict clean = Verdict.Clean;
			int ceiling;
			string what;
			float distance;
			float allowed;
			if ((Object)(object)__1 != (Object)null && !Owns(current, __1))
			{
				clean = Verdict.Certain("creature-damage-spoof", $"claimed {__2} damage to a creature as {NameOf(__1)}");
			}
			else if (!OneShotOn() && Weapons.IsImpossible(__1, __2, Weapons.CreatureScale(), bareHandsBound: false, out ceiling, out what))
			{
				clean = Verdict.Certain("creature-damage-above-weapon", $"{__2} damage to a creature using {what}, which cannot exceed {ceiling}");
			}
			else if (Plugin.WatchReach.Value && Reach.TooFarFromPoint(__1, __3, out distance, out allowed))
			{
				clean = Verdict.Certain("creature-hit-from-nowhere", $"hit a creature {distance:0}m away, but their reach is {allowed:0}m");
			}
			else
			{
				Verdict verdict2;
				Verdict verdict = (verdict2 = Aim.NoteHit(current, __1, __3));
				clean = (verdict.IsHostile ? verdict2 : ((OneShotOn() || __2 <= Plugin.MaxPlausibleDamage.Value) ? Limit(current, "hitcreature", Plugin.HitsPerMinute.Value, "creature hits") : Verdict.Certain("creature-damage-impossible", $"{__2} damage to a creature (absolute ceiling {Plugin.MaxPlausibleDamage.Value})")));
			}
			return Apply(current, "HitCreature", clean);
		}

		public static bool MeleeAttack_Pre(Melee __0, Transform __1, bool __2, Vector3 __3)
		{
			return Guarded((NetworkConnection conn) => Extras.TryDetonate(Sender.PlayerFor(conn)) ? Verdict.Clean : Limit(conn, "melee", Plugin.HitsPerMinute.Value, "melee swings"), "MeleeAttack");
		}

		public static bool Punch_Pre(Player __0, Transform __1, bool __2, Vector3 __3)
		{
			return Guarded((NetworkConnection conn) => Extras.TryDetonate(Sender.PlayerFor(conn)) ? Verdict.Clean : Limit(conn, "punch", Plugin.HitsPerMinute.Value, "punches"), "Punch");
		}

		public static bool ActivateExplosive_Pre(Explosive __0, uint __1, bool __2, bool __3, Player __4)
		{
			return Guarded((NetworkConnection conn) => (!((Object)(object)__4 != (Object)null) || Owns(conn, __4)) ? Limit(conn, "explosive", Plugin.ExplosivesPerMinute.Value, "detonations") : Verdict.Certain("remote-detonate", "detonated an explosive as " + NameOf(__4)), "ActivateExplosive");
		}

		public static bool SendChatMessage_Pre(ulong __0, string __1)
		{
			NetworkConnection current = Sender.Current;
			if (Skip(current))
			{
				return true;
			}
			if (Actions.ShouldMute(current))
			{
				return false;
			}
			Verdict clean = Verdict.Clean;
			Player val = Sender.PlayerFor(current);
			ulong num = 0uL;
			try
			{
				if ((Object)(object)val != (Object)null)
				{
					num = val.SteamID;
				}
			}
			catch
			{
			}
			clean = ((num == 0L || __0 == 0L || __0 == num) ? Limit(current, "chat", Plugin.ChatPerMinute.Value, "chat messages") : Verdict.Certain("chat-impersonation", $"sent chat claiming to be steam id {__0}"));
			return Apply(current, "SendChatMessage", clean);
		}

		public static bool SetDriver_Pre(Player __0)
		{
			return Guarded((NetworkConnection conn) => (!((Object)(object)__0 != (Object)null) || Owns(conn, __0)) ? Verdict.Clean : Verdict.Certain("boat-hijack", "made " + NameOf(__0) + " the driver"), "SetDriver");
		}

		public static bool SetItemSkin_Pre(Item __0, byte __1)
		{
			return Guarded((NetworkConnection conn) => Limit(conn, "skin", Plugin.CosmeticPerMinute.Value, "skin changes"), "SetItemSkin");
		}

		public static bool SetBoatSkin_Pre(byte __0)
		{
			return Guarded((NetworkConnection conn) => Limit(conn, "boatskin", Plugin.CosmeticPerMinute.Value, "boat skin changes"), "SetBoatSkin");
		}

		public static bool PlaceBet_Pre(byte __0)
		{
			return Guarded((NetworkConnection conn) => Limit(conn, "bet", Plugin.BetsPerMinute.Value, "bets"), "PlaceBet");
		}

		public static bool FinishEatingCreature_Pre(Creature __0, Player __1)
		{
			return Guarded((NetworkConnection conn) => (!((Object)(object)__1 != (Object)null) || Owns(conn, __1)) ? Limit(conn, "eat", Plugin.EatsPerMinute.Value, "creatures eaten") : Verdict.Certain("eat-as-other", "finished eating a creature as " + NameOf(__1)), "FinishEatingCreature");
		}

		public static bool ToggleEatCreature_Pre(Player __0, bool __1)
		{
			return Guarded((NetworkConnection conn) => (!((Object)(object)__0 != (Object)null) || Owns(conn, __0)) ? Verdict.Clean : Verdict.Certain("eat-toggle-other", "started " + NameOf(__0) + " eating"), "ToggleEatCreature");
		}

		public static bool AddProjectile_Pre(Player __0, WeaponInfo __1, uint __2, uint __3, Vector3 __4, Vector3 __5)
		{
			return Guarded(delegate(NetworkConnection conn)
			{
				if ((Object)(object)__0 != (Object)null && !Owns(conn, __0))
				{
					return Verdict.Certain("projectile-spoof", "fired a projectile as " + NameOf(__0));
				}
				if (Extras.TryDetonate(__0))
				{
					return Verdict.Clean;
				}
				Aim.NoteShot(conn);
				Verdict verdict = Firing.Shot(conn, __0);
				return verdict.IsHostile ? verdict : Limit(conn, "projectile", Plugin.ProjectilesPerMinute.Value, "shots");
			}, "AddProjectile");
		}

		public static bool AddProjectiles_Pre(Player __0, WeaponInfo __1, uint __2, uint __3, Vector3 __4, Vector3[] __5)
		{
			return Guarded(delegate(NetworkConnection conn)
			{
				if ((Object)(object)__0 != (Object)null && !Owns(conn, __0))
				{
					return Verdict.Certain("projectile-spoof", "fired a volley as " + NameOf(__0));
				}
				if (Extras.TryDetonate(__0))
				{
					return Verdict.Clean;
				}
				int num = ((__5 != null) ? __5.Length : 0);
				if (num > _mostPellets)
				{
					_mostPellets = num;
					Plugin.Log.LogInfo((object)("[Rules] biggest honest volley so far: " + num + " projectiles (ceiling " + Plugin.MaxProjectilesPerShot.Value + "). If a real weapon is reaching the ceiling, this is the number to raise it past."));
				}
				if (num > Plugin.MaxProjectilesPerShot.Value)
				{
					if (num < Plugin.MaxProjectilesPerShot.Value * 2)
					{
						Plugin.Log.LogWarning((object)($"[Rules] {num} projectiles in one shot against a " + $"ceiling of {Plugin.MaxProjectilesPerShot.Value} - close enough to " + "the ceiling that this is more likely a real weapon than an attack. Raise CatchLimit/MaxProjectilesPerShot in the config; the code default no longer applies once the file exists."));
						return Verdict.Strong("projectile-flood", $"{num} projectiles in a single shot (ceiling " + $"{Plugin.MaxProjectilesPerShot.Value}, which may simply be too low)");
					}
					return Verdict.Certain("projectile-flood", $"{num} projectiles in a single shot (ceiling {Plugin.MaxProjectilesPerShot.Value})");
				}
				Aim.NoteShot(conn);
				Verdict verdict = Firing.Shot(conn, __0);
				return verdict.IsHostile ? verdict : Limit(conn, "projectile", Plugin.ProjectilesPerMinute.Value, "shots");
			}, "AddProjectiles");
		}

		public static bool ProjectileHitDynamic_Pre(NetworkConnection __0, uint __1)
		{
			return Guarded((NetworkConnection conn) => Limit(conn, "projhit", Plugin.ProjectilesPerMinute.Value, "projectile hits"), "ProjectileHitDynamic");
		}

		public static bool ReleaseItemFromBait_Pre(FishingRod __0)
		{
			return Guarded(delegate(NetworkConnection conn)
			{
				Player val = HolderOf((Component)(object)__0);
				return (!((Object)(object)val != (Object)null) || Owns(conn, val)) ? Limit(conn, "bait", Plugin.BaitReleasesPerMinute.Value, "catches released") : Verdict.Certain("bait-release-other", "released a catch from " + NameOf(val) + "'s rod");
			}, "ReleaseItemFromBait");
		}

		private static bool Guarded(Func<NetworkConnection, Verdict> judge, string rpc)
		{
			NetworkConnection current = Sender.Current;
			if (Skip(current))
			{
				return true;
			}
			return Apply(current, rpc, judge(current));
		}

		private static Player HolderOf(Component tool)
		{
			if ((Object)(object)tool == (Object)null)
			{
				return null;
			}
			try
			{
				Item component = tool.GetComponent<Item>();
				return ((Object)(object)component != (Object)null) ? component.Holder : null;
			}
			catch
			{
				return null;
			}
		}

		private static string ItemLabel(Item i)
		{
			if ((Object)(object)i == (Object)null)
			{
				return "an item";
			}
			try
			{
				return (((Object)i).name ?? "an item").Replace("(Clone)", "").Trim();
			}
			catch
			{
				return "an item";
			}
		}

		private static Verdict Limit(NetworkConnection conn, string what, int perMinute, string label)
		{
			if (perMinute <= 0)
			{
				return Verdict.Clean;
			}
			string key = (conn?.ClientId ?? (-1)) + ":" + what;
			float realtimeSinceStartup = Time.realtimeSinceStartup;
			if (!_buckets.TryGetValue(key, out var value))
			{
				value = new Bucket
				{
					WindowStart = realtimeSinceStartup
				};
				_buckets[key] = value;
			}
			if (realtimeSinceStartup - value.WindowStart >= 60f)
			{
				value.WindowStart = realtimeSinceStartup;
				value.Count = 0;
			}
			value.Count++;
			if (value.Count <= perMinute)
			{
				return Verdict.Clean;
			}
			if (realtimeSinceStartup - value.LastFinding < Plugin.MovementFindingCooldown.Value)
			{
				return Verdict.Clean;
			}
			value.LastFinding = realtimeSinceStartup;
			return Verdict.Strong("catch-limit", $"{value.Count} {label} in under a minute (ceiling {perMinute})");
		}

		public static void ResetLimits()
		{
			_buckets.Clear();
		}
	}
	internal static class GuardSettings
	{
		private static bool _open;

		private static Vector2 _scroll;

		public static void Draw()
		{
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: 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)
			if (GUILayout.Button(_open ? "Hide warden settings" : "Warden settings", (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.Height(26f),
				GUILayout.Width(200f)
			}))
			{
				_open = !_open;
			}
			if (_open)
			{
				_scroll = GUILayout.BeginScrollView(_scroll, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(200f) });
				Enforcement();
				Theme.Rule();
				TrollTuning();
				Theme.Rule();
				Detection();
				Theme.Rule();
				Records();
				GUILayout.EndScrollView();
			}
		}

		private static void Enforcement()
		{
			Theme.Header("ENFORCEMENT");
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			if (Toggle(Plugin.AutoKick.Value, Plugin.AutoKick.Value ? "Removes on its own" : "Asks me first", 170))
			{
				Plugin.AutoKick.Value = !Plugin.AutoKick.Value;
			}
			if (Toggle(Plugin.Quiet.Value, Plugin.Quiet.Value ? "Quiet" : "Announces", 110))
			{
				Plugin.Quiet.Value = !Plugin.Quiet.Value;
			}
			if (Toggle(Plugin.EnforceBans.Value, "Bans stick", 110))
			{
				Plugin.EnforceBans.Value = !Plugin.EnforceBans.Value;
			}
			GUILayout.EndHorizontal();
			IntSlider("Strikes before removal", Plugin.KickThreshold, 10, 100);
			Slider("Grace period (min)", Plugin.WarmupMinutes, 0f, 15f, "0.0");
			IntSlider("Stand down after N unproven", Plugin.BreakerPlayers, 0, 8);
		}

		private static void TrollTuning()
		{
			Theme.Header("TROLL");
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			AutoTroll.Trigger mode = AutoTroll.Mode;
			if (GUILayout.Button("Arms: " + ((mode == AutoTroll.Trigger.Off) ? "never" : mode.ToString()), (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.Width(190f),
				GUILayout.Height(26f)
			}))
			{
				AutoTroll.SetMode((mode != AutoTroll.Trigger.ChosenRules) ? (mode + 1) : AutoTroll.Trigger.Off);
				Toast(AutoTroll.Summary());
			}
			if (Toggle(Plugin.TrollTaunts.Value, Plugin.TrollTaunts.Value ? "Talking" : "Silent", 100))
			{
				Plugin.TrollTaunts.Value = !Plugin.TrollTaunts.Value;
			}
			GUILayout.EndHorizontal();
			Slider("Shove every (s)", Plugin.TrollJostleInterval, 0.3f, 6f, "0.0");
			Slider("Shove distance (m)", Plugin.TrollJostleRadius, 0.5f, 8f, "0.0");
			Slider("Remark every (s)", Plugin.TrollIdleInterval, 10f, 120f, "0");
			IntSlider("Arms after strikes", Plugin.AutoTrollStrikes, 10, 100);
		}

		private static void Detection()
		{
			Theme.Header("HOW SUSPICIOUS TO BE");
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			if (Toggle(Plugin.WatchMovement.Value, "Movement", 110))
			{
				Plugin.WatchMovement.Value = !Plugin.WatchMovement.Value;
			}
			if (Toggle(Plugin.WatchFiring.Value, "Shooting", 110))
			{
				Plugin.WatchFiring.Value = !Plugin.WatchFiring.Value;
			}
			if (Toggle(Plugin.WatchReach.Value, "Distance", 110))
			{
				Plugin.WatchReach.Value = !Plugin.WatchReach.Value;
			}
			if (Toggle(Plugin.WatchAim.Value, "Aim", 90))
			{
				Plugin.WatchAim.Value = !Plugin.WatchAim.Value;
			}
			GUILayout.EndHorizontal();
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			if (Toggle(Plugin.PutFlyersDown.Value, "Put flyers down", 150))
			{
				Plugin.PutFlyersDown.Value = !Plugin.PutFlyersDown.Value;
			}
			if (Toggle(Plugin.CheckNoclip.Value, "Walls", 90))
			{
				Plugin.CheckNoclip.Value = !Plugin.CheckNoclip.Value;
			}
			if (Toggle(Plugin.BlockCrashPackets.Value, "Crash packets", 140))
			{
				Plugin.BlockCrashPackets.Value = !Plugin.BlockCrashPackets.Value;
			}
			GUILayout.EndHorizontal();
			Slider("Lag tolerance", Plugin.SlackLine, 1f, 4f, "0.0");
			Slider("Damage headroom", Plugin.DamageTolerance, 1f, 4f, "0.0");
			Slider("Seconds airborne = flying", Plugin.FlightSeconds, 1f, 10f, "0.0");
			Slider("Height that means flying (m)", Plugin.MaxJumpHeight, 4f, 30f, "0");
		}

		private static void Records()
		{
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			Theme.Header("RECORD KEEPING");
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			if (Toggle(Plugin.CaptureEvidence.Value, "Screenshots", 130))
			{
				Plugin.CaptureEvidence.Value = !Plugin.CaptureEvidence.Value;
			}
			if (Toggle(Plugin.TraceUnguarded.Value, "Log unknown traffic", 180))
			{
				Plugin.TraceUnguarded.Value = !Plugin.TraceUnguarded.Value;
			}
			GUILayout.EndHorizontal();
			IntSlider("Screenshot limit", Plugin.EvidenceSessionCap, 5, 200);
			GUILayout.Space(4f);
			Theme.Line(Logbook.Folder, Theme.Faint, 11);
		}

		private static bool Toggle(bool on, string label, int width)
		{
			//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_0033: 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_0074: Unknown result type (might be due to invalid IL or missing references)
			Color backgroundColor = GUI.backgroundColor;
			GUI.backgroundColor = (on ? new Color(0.3f, 0.62f, 0.82f) : new Color(1f, 1f, 1f, 0.1f));
			bool result = GUILayout.Button((on ? "✓  " : "     ") + label, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.Width((float)width),
				GUILayout.Height(26f)
			});
			GUI.backgroundColor = backgroundColor;
			return result;
		}

		private static void Slider(string label, ConfigEntry<float> cfg, float min, float max, string fmt)
		{
			//IL_000b: 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)
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			Theme.Line(label, Theme.Muted, 12);
			GUILayout.FlexibleSpace();
			Theme.Line(cfg.Value.ToString(fmt), Theme.Ink, 12);
			GUILayout.EndHorizontal();
			float num = GUILayout.HorizontalSlider(cfg.Value, min, max, Array.Empty<GUILayoutOption>());
			if (Mathf.Abs(num - cfg.Value) > 0.0001f)
			{
				cfg.Value = num;
			}
			GUILayout.Space(2f);
		}

		private static void IntSlider(string label, ConfigEntry<int> cfg, int min, int max)
		{
			//IL_000b: 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)
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			Theme.Line(label, Theme.Muted, 12);
			GUILayout.FlexibleSpace();
			Theme.Line(cfg.Value.ToString(), Theme.Ink, 12);
			GUILayout.EndHorizontal();
			int num = Mathf.RoundToInt(GUILayout.HorizontalSlider((float)cfg.Value, (float)min, (float)max, Array.Empty<GUILayoutOption>()));
			if (num != cfg.Value)
			{
				cfg.Value = num;
			}
			GUILayout.Space(2f);
		}

		private static void Toast(string msg)
		{
			Dashboard.Toast(msg);
		}
	}
	internal static class Hazing
	{
		public static readonly Dictionary<string, string[]> Reactions;

		public static readonly string[][] Idle;

		public static readonly string[] Opening;

		public static readonly string[] Closing;

		public static readonly Dictionary<string, string[]> Shame;

		private static readonly string[] Generic;

		public static string ShameFor(string rule, int roll)
		{
			if (rule == null || !Shame.TryGetValue(rule, out var value) || value.Length == 0)
			{
				value = Generic;
			}
			return value[Math.Abs(roll) % value.Length];
		}

		static Hazing()
		{
			Dictionary<string, string[]> dictionary = new Dictionary<string, string[]>();
			dictionary["free-purchase"] = new string[4] { "{0} tried to pull a fish out of an empty bucket. The bucket won.", "{0} reached into a tackle box that has never existed and came up with a fistful of nothing.", "Somebody tell {0} the shop is that way, and it takes money.", "{0} attempted to catch something without going near the water. Bold. Wrong, but bold." };
			dictionary["not-for-sale"] = new string[3] { "{0} is shopping from a catalogue nobody else can see, and buying nothing from it.", "No stall on this island sells what {0} just tried to order.", "{0} keeps asking the sea for a receipt." };
			dictionary["bought-a-creature"] = new string[4] { "{0} tried to summon a fish out of thin air. The fish declined the invitation.", "You catch fish, {0}. You do not order them.", "{0} has attempted to conjure a whale on a beginner's island. The whale is not coming.", "Every real angler here caught theirs. {0} is still trying to invent one." };
			dictionary["bought-unpriced"] = new string[1] { "{0} is trying to walk off with stock that was never on the shelf." };
			dictionary["teleport-self"] = new string[4] { "{0} tried to slip away across the water and is still standing exactly where they were.", "There is no shortcut to the good fishing, {0}. There never was.", "{0} attempted to vanish. The tide had other ideas.", "Landlubber trick. Didn't work." };
			dictionary["teleport-other"] = new string[2] { "{0} tried to drag someone else across the map. Nobody moved an inch.", "Keep your hands off the crew, {0}." };
			dictionary["respawn-other"] = new string[1] { "{0} tried to relocate a fellow angler like a piece of tackle. Denied." };
			dictionary["flying"] = new string[4] { "{0} is airborne again. Somebody fetch the landing net.", "Fish swim, {0}. Anglers stand on the dock. Pick one.", "{0} has left the ground for reasons known only to {0}.", "Gravity has been notified about {0} and is on its way." };
			dictionary["persistent-flight"] = new string[2] { "{0} has been hauled back down more times than a snagged line and still hasn't taken the hint.", "That's the eighth time we've scraped {0} off the sky." };
			dictionary["walking-on-water"] = new string[5] { "There's only ever been one fella who walked on water, {0}, and you ain't him.", "{0} is standing on the sea. Last man who managed that got a book written about him. You're getting a warning.", "Down you come, {0}. The water's for swimming in.", "{0} out there strolling across the bay like the Almighty. The Almighty could fish, though.", "Miracles are above your pay grade, {0}." };
			dictionary["noclip"] = new string[2] { "{0} just went straight through a wall. The wall's fine. {0} is a different matter.", "Doors, {0}. We have those here." };
			dictionary["auto-fire"] = new string[3] { "{0}'s rod is making a noise no rod should make.", "{0} has found a trigger speed the manufacturer never tested and the sea does not respect.", "That gun was built for fish, {0}, not for whatever that was." };
			dictionary["projectile-flood"] = new string[2] { "shame on me for firing a shotgun that thinks it is a swarm", "shame on me for putting a whole box of shells down one barrel" };
			dictionary["no-reload"] = new string[3] { "{0} has now fired more rounds than the magazine holds. The magazine would like a word.", "{0}'s ammo box appears to be a portal. It has been sealed.", "Count your shots, {0}. Everyone else has to." };
			dictionary["shot-through-wall"] = new string[2] { "{0} shot straight through solid timber. The timber is unmarked. So is the target.", "{0} is aiming at things they cannot see, and hitting none of them." };
			dictionary["perfect-accuracy"] = new string[1] { "{0} hasn't missed once all evening. Nobody believes it either." };
			dictionary["damage-above-weapon"] = new string[3] { "{0} swung with the force of a trawler and connected with absolutely nothing.", "That punch was written on paper, {0}. It didn't arrive.", "{0} is hitting well above their weight class, and well outside the rules." };
			dictionary["hit-from-nowhere"] = new string[3] { "{0} attacked from an address they do not live at.", "{0} is throwing punches from the next island over. They are not landing.", "Come closer if you want to swing, {0}. That's how arms work." };
			dictionary["damage-spoof"] = new string[1] { "{0} tried to pin their handiwork on somebody else. We saw." };
			dictionary["creature-damage-above-weapon"] = new string[1] { "{0} hit a fish harder than any tackle on this island allows. The fish is unbothered." };
			dictionary["bait-not-owned"] = new string[3] { "{0} is fishing with bait they never bought, and catching nothing on it.", "That's a fine lure, {0}. Shame about the part where you never paid for it.", "Stolen bait, empty bucket. Poetic, really." };
			dictionary["bait-set-other"] = new string[1] { "{0} went through someone else's tackle box. Hands off." };
			dictionary["worth-inflation"] = new string[2] { "{0} tried to sell a shrimp for the price of a boat. The buyer laughed.", "That's a common fish, {0}. It has always been a common fish." };
			dictionary["self-revive"] = new string[2] { "{0} hauled themselves back up off the deck. Nobody clapped.", "{0} performed emergency care on their own corpse. Denied, and slightly disturbing." };
			dictionary["force-drop"] = new string[1] { "{0} tried to empty somebody else's pockets into the sea." };
			dictionary["physics-grab"] = new string[1] { "{0} put their hands on gear that isn't theirs." };
			dictionary["item-move"] = new string[3] { "{0} has been shifting gear that belongs to somebody else.", "Keep your hands in your own tackle box, {0}.", "{0} moved another angler's catch. Bold thing to do on a small dock." };
			dictionary["inventory-take"] = new string[2] { "{0} just went through someone else's pockets.", "Thieving from a fellow fisherman, {0}. There's a word for that and it isn't angler." };
			dictionary["inventory-push"] = new string[1] { "{0} tried to stuff something into another angler's bag. Nobody wants it, {0}." };
			dictionary["npc-take"] = new string[2] { "{0} tried to take a reward that was never offered to them.", "That quest wasn't yours, {0}." };
			dictionary["pocket-unlock"] = new string[1] { "{0} attempted to pick a lock that isn't on their own bag." };
			dictionary["force-drop"] = new string[1] { "{0} tried to tip somebody else's bucket into the sea." };
			dictionary["boat-hijack"] = new string[3] { "{0} tried to take the wheel of a boat they aren't even standing on.", "Hands off the tiller, {0}.", "{0} attempted a mutiny from the shore. It went about as well as you'd expect." };
			dictionary["bait-release-other"] = new string[2] { "{0} cut somebody else's line. That's the lowest thing you can do on a dock.", "{0} went after another angler's catch mid-fight." };
			dictionary["eat-as-other"] = new string[2] { "{0} tried to eat a fish out of another man's hands.", "That wasn't your supper, {0}." };
			dictionary["eat-toggle-other"] = new string[1] { "{0} tried to make somebody else start chewing. Leave them be." };
			dictionary["catch-limit"] = new string[3] { "{0} is working faster than any pair of human hands ever has.", "Slow down, {0}. The fish aren't going anywhere and neither are you.", "There's a limit, {0}, and you sailed past it some time ago." };
			dictionary["chum"] = new string[2] { "{0} went up and collected bait floating eighty metres in the air. Caught red-handed.", "The bait was in the sky, {0}. You went and got it. That's a confession." };
			dictionary["projectile-spoof"] = new string[1] { "{0} fired a shot and tried to sign somebody else's name on it." };
			dictionary["projectile-flood"] = new string[2] { "{0} loosed more shot in one pull than any barrel could hold.", "That wasn't a shotgun, {0}. That was a swarm." };
			dictionary["reload-other"] = new string[1] { "{0} tried to reload a gun that isn't in their hands." };
			dictionary["damage-impossible"] = new string[2] { "{0} swung with a force no tackle on this island can produce.", "Nothing you own hits that hard, {0}. Nothing anyone owns does." };
			dictionary["creature-damage-impossible"] = new string[1] { "{0} hit a fish hard enough to sink a trawler. The fish declined to notice." };
			dictionary["creature-damage-spoof"] = new string[1] { "{0} tried to claim somebody else's catch as their own handiwork." };
			dictionary["creature-hit-from-nowhere"] = new string[2] { "{0} is landing fish from six hundred metres away. Impressive cast. Fictional, but impressive.", "The fish are over there, {0}. You are not." };
			dictionary["remote-detonate"] = new string[2] { "{0} set off a charge from somewhere they aren't standing.", "Dynamite works better when you're actually near it, {0}." };
			dictionary["speed"] = new string[2] { "{0} is moving quicker than any boots on this island allow.", "Nobody walks that fast, {0}. Not even downhill." };
			dictionary["flight"] = new string[2] { "{0} appears to be having trouble staying on the ground.", "Something's keeping {0} off the deck and it isn't the wind." };
			dictionary["chat-impersonation"] = new string[2] { "{0} just tried to speak in somebody else's voice. We all heard whose it really was.", "Nice try, {0}. Your name is still on it." };
			dictionary["force-finish"] = new string[2] { "{0} tried to call the whole day off for everyone. Not your call, {0}.", "{0} attempted to end the run for eight people. Sit down." };
			dictionary["purchase-other"] = new string[1] { "{0} went shopping on somebody else's tab." };
			dictionary["worth-nudge"] = new string[1] { "{0} has been quietly adjusting what their catch is worth." };
			dictionary["clone-spawn"] = new string[3] { "{0} has tried to bring a second {0} to the dock. One is plenty.", "There is already a {0} here and nobody was pleased about the first one.", "{0} attempted to clone themselves. The sea does not need more of that." };
			dictionary["lobby-crash"] = new string[1] { "{0} just tried to sink the whole boat with everyone on it. That one isn't funny." };
			Reactions = dictionary;
			Idle = new string[3][]
			{
				new string[4] { "{0} seems to be having a spot of bother.", "Is anyone helping {0}? They've been out there a while.", "{0} is fishing. After a fashion.", "Rough day on the water for {0}." },
				new string[5] { "{0} has now dropped everything for the {1}th time. We are counting.", "Still nothing in {0}'s bucket.", "{0} continues to wrestle with forces well beyond their understanding.", "Every angler here has caught something today except {0}.", "{0} came all this way to stand in the shallows and fail." },
				new string[6] { "{0} has achieved precisely nothing this entire session and shows no sign of stopping.", "Somebody ought to tell {0}. Nobody is going to tell {0}.", "{0} remains loyal to a technique that has never once worked for anybody.", "At this point {0} is simply providing entertainment for the rest of the dock.", "The fish have started ignoring {0} out of pity.", "{0}: all the gear, none of the idea." }
			};
			Opening = new string[3] { "{0} has been marked. The sea has opinions about {0}.", "Eyes on {0}. This should be good.", "{0} is on the warden's list. Enjoy the show." };
			Closing = new string[2] { "{0} has been let off. Behave.", "The sea is done with {0}. For now." };
			Shame = new Dictionary<string, string[]>
			{
				["worth-inflation"] = new string[3] { "shame on me for pricing a common fish like a wedding ring", "shame on me for inventing money in front of everyone", "shame on me for selling the same fish twice and hoping nobody counted" },
				["free-purchase"] = new string[2] { "shame on me for walking out without paying", "shame on me for shopping with an empty wallet and a full basket" },
				["bought-a-creature"] = new string[2] { "shame on me for trying to buy a fish I could not catch", "shame on me for ordering a whale like it was a sandwich" },
				["not-for-sale"] = new string[1] { "shame on me for shopping from a catalogue nobody else can see" },
				["catch-limit"] = new string[1] { "shame on me for reeling faster than the sea can refill" },
				["teleport-self"] = new string[2] { "shame on me for skipping the walk everyone else took", "shame on me for trying to be somewhere I did not earn" },
				["teleport-other"] = new string[1] { "shame on me for moving somebody who did not ask to be moved" },
				["flying"] = new string[1] { "shame on me for fishing from the sky like a seagull with a licence" },
				["walking-on-water"] = new string[1] { "shame on me for standing on the sea as if I had been invited" },
				["noclip"] = new string[1] { "shame on me for walking through a wall that was doing its best" },
				["chat-impersonation"] = new string[2] { "shame on me for putting words in somebody else's mouth", "shame on me for speaking as a person who was standing right there" },
				["eat-as-other"] = new string[1] { "shame on me for eating out of somebody else's hands" },
				["inventory-take"] = new string[1] { "shame on me for going through pockets that were not mine" },
				["respawn-other"] = new string[1] { "shame on me for deciding when somebody else gets up" },
				["self-revive"] = new string[1] { "shame on me for refusing to stay down like everybody else" },
				["no-reload"] = new string[2] { "shame on me for a magazine that never ends", "shame on me for firing a gun that forgot how many it holds" },
				["auto-fire"] = new string[1] { "shame on me for pulling a trigger faster than a finger can" },
				["shot-through-wall"] = new string[1] { "shame on me for shooting through something solid and calling it aim" },
				["remote-detonate"] = new string[1] { "shame on me for setting off something I was nowhere near" },
				["clone-spawn"] = new string[1] { "shame on me for filling the lobby with copies of myself" }
			};
			Generic = new string[3] { "shame on me for cheating at a fishing game", "shame on me for taking a shortcut in front of witnesses", "shame on me for being caught doing something the sea never offered" };
		}
	}
	internal static class HostTools
	{
		private static Traverse _rig;

		private static object _rigOwner;

		private static bool _hadGravity = true;

		public static bool Flying { get; private set; }

		public static bool FriendlyFire
		{
			get
			{
				try
				{
					return ServerSettings.UseFriendlyFire;
				}
				catch
				{
					return false;
				}
			}
		}

		public static string GoTo(int index)
		{
			if (!Plugin.IsHosting)
			{
				return "Only the host can move the lobby.";
			}
			int num;
			try
			{
				num = IslandManager.TotalIslands;
			}
			catch
			{
				num = 6;
			}
			if (index < 0 || index >= num)
			{
				return $"Islands are 1 to {num} (that is index 0 to {num - 1}).";
			}
			try
			{
				OnlineIslandManager.TpToSpecificIsland((byte)index);
				return $"Everyone moved to island {index + 1} of {num}.";
			}
			catch (Exception ex)
			{
				return "Could not travel: " + ex.Message;
			}
		}

		public static string Next(bool backwards)
		{
			int curIsland;
			int totalIslands;
			try
			{
				curIsland = OnlineIslandManager.CurIsland;
				totalIslands = IslandManager.TotalIslands;
			}
			catch
			{
				return "Island state unavailable.";
			}
			int num = (backwards ? (curIsland - 1) : (curIsland + 1));
			if (num < 0)
			{
				num = totalIslands - 1;
			}
			if (num >= totalIslands)
			{
				num = 0;
			}
			return GoTo(num);
		}

		public static string Where()
		{
			try
			{
				byte curIsland = OnlineIslandManager.CurIsland;
				int totalIslands = IslandManager.TotalIslands;
				byte maxIslandUnlocked = OnlineIslandManager.MaxIslandUnlocked;
				return $"Island {curIsland + 1} of {totalIslands} (unlocked up to {maxIslandUnlocked}).";
			}
			catch
			{
				return "Island state unavailable.";
			}
		}

		public static string ToggleFly()
		{
			Flying = !Flying;
			if (!Flying)
			{
				RestoreGravity();
			}
			if (!Flying)
			{
				return "Fly off.";
			}
			return "Fly on. WASD to move, Space up, Ctrl down, Shift to go faster.";
		}

		public static void Move_Post(PlayerMovement __instance)
		{
			//IL_00cc: 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_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: 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_00f0: 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_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: 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_0113: 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_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: 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_0128: Unknown result type (might be due to invalid IL or missing references)
			//IL_012a: 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_013a: 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)
			//IL_013e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0143: Unknown result type (might be due to invalid IL or missing references)
			//IL_014e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0150: Unknown result type (might be due to invalid IL or missing references)
			//IL_0155: 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)
			//IL_0171: 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_0178: Unknown result type (might be due to invalid IL or missing references)
			//IL_017d: 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_01a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01be: Unknown result type (might be due to invalid IL or missing references)
			if (!Flying)
			{
				return;
			}
			try
			{
				Player localPlayer = Player.LocalPlayer;
				if ((Object)(object)localPlayer == (Object)null || (Object)(object)localPlayer.Movement != (Object)(object)__instance)
				{
					return;
				}
				if (_rigOwner != __instance)
				{
					_rigOwner = __instance;
					_rig = Traverse.Create((object)__instance).Field("_rig");
					_hadGravity = true;
				}
				Rigidbody val = ((_rig != null && _rig.FieldExists()) ? _rig.GetValue<Rigidbody>() : null);
				if (!((Object)(object)val == (Object)null))
				{
					if (val.useGravity)
					{
						_hadGravity = true;
						val.useGravity = false;
					}
					Transform val2 = (((Object)(object)localPlayer.CurCam != (Object)null) ? ((Component)localPlayer.CurCam).transform : null);
					Vector3 val3 = (((Object)(object)val2 != (Object)null) ? val2.forward : ((Component)localPlayer).transform.forward);
					Vector3 val4 = (((Object)(object)val2 != (Object)null) ? val2.right : ((Component)localPlayer).transform.right);
					Vector3 val5 = Vector3.zero;
					if (Input.GetKey((KeyCode)119))
					{
						val5 += val3;
					}
					if (Input.GetKey((KeyCode)115))
					{
						val5 -= val3;
					}
					if (Input.GetKey((KeyCode)100))
					{
						val5 += val4;
					}
					if (Input.GetKey((KeyCode)97))
					{
						val5 -= val4;
					}
					if (Input.GetKey((KeyCode)32))
					{
						val5 += Vector3.up;
					}
					if (Input.GetKey((KeyCode)306) || Input.GetKey((KeyCode)99))
					{
						val5 += Vector3.down;
					}
					float num = Plugin.FlySpeed.Value;
					if (Input.GetKey((KeyCode)304))
					{
						num *= Plugin.FlyBoost.Value;
					}
					val.linearVelocity = ((val5 == Vector3.zero) ? Vector3.zero : (((Vector3)(ref val5)).normalized * num));
				}
			}
			catch
			{
			}
		}

		private static void RestoreGravity()
		{
			try
			{
				Rigidbody val = ((_rig != null && _rig.FieldExists()) ? _rig.GetValue<Rigidbody>() : null);
				if ((Object)(object)val != (Object)null && _hadGravity)
				{
					val.useGravity = true;
				}
			}
			catch
			{
			}
		}

		public static void Install(Harmony h)
		{
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Expected O, but got Unknown
			try
			{
				MethodInfo methodInfo = AccessTools.Method(typeof(PlayerMovement), "Move", (Type[])null, (Type[])null);
				if (methodInfo == null)
				{
					Plugin.Log.LogWarning((object)"[HostTools] PlayerMovement.Move not found - fly unavailable.");
				}
				else
				{
					h.Patch((MethodBase)methodInfo, (HarmonyMethod)null, new HarmonyMethod(AccessTools.Method(typeof(HostTools), "Move_Post", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				}
			}
			catch (Exception ex)
			{
				Plugin.Log.LogError((object)("[HostTools] fly unavailable: " + ex.Message));
			}
		}

		public static string ToggleFriendlyFire()
		{
			if (!Plugin.IsHosting)
			{
				return "Only the host can change that.";
			}
			try
			{
				bool flag = !ServerSettings.UseFriendlyFire;
				Traverse val = Traverse.Create(typeof(ServerSettings)).Property("UseFriendlyFire", (object[])null);
				if (val != null && val.PropertyExists())
				{
					val.SetValue((object)flag);
				}
				else
				{
					Traverse.Create(typeof(ServerSettings)).Field("_useFriendlyFire").SetValue((object)flag);
				}
				bool useFriendlyFire = ServerSettings.UseFriendlyFire;
				Plugin.Log.LogInfo((object)("[HostTools] friendly fire -> " + useFriendlyFire));
				return useFriendlyFire ? "Friendly fire ON - players can hurt each other." : "Friendly fire OFF - punches between players do nothing. That is the game's setting, not the guard.";
			}
			catch (Exception ex)
			{
				return "Could not change it: " + ex.Message;
			}
		}
	}
	internal static class JoinFixPatches
	{
		[HarmonyPatch(typeof(Player), "InitializePlayer")]
		internal static class Player_InitializePlayer_Patch
		{
			private static bool Prefix(Player __instance)
			{
				if (_reentering)
				{
					return true;
				}
				NetworkConnection owner;
				try
				{
					owner = ((NetworkBehaviour)__instance).Owner;
				}
				catch (Exception ex)
				{
					Plugin.Log.LogWarning((object)("[JoinFix] could not read Owner: " + ex.Message));
					return true;
				}
				if (owner != (NetworkConnection)null && Client.Clients.ContainsKey(owner))
				{
					return true;
				}
				if (!_pending.Add(__instance))
				{
					return false;
				}
				Plugin.Log.LogWarning((object)("[JoinFix] Client object for connection " + ((owner == (NetworkConnection)null) ? "<null>" : owner.ClientId.ToString()) + " hasn't spawned yet — deferring InitializePlayer instead of letting it crash the spawn batch."));
				Plugin instance = Plugin.Instance;
				if ((Object)(object)instance == (Object)null)
				{
					_pending.Remove(__instance);
					return true;
				}
				((MonoBehaviour)instance).StartCoroutine(WaitForClientThenInitialize(__instance, owner));
				return false;
			}
		}

		private static bool _reentering;

		private static readonly HashSet<Player> _pending = new HashSet<Player>();

		private static readonly MethodInfo InitializePlayerMethod = AccessTools.Method(typeof(Player), "InitializePlayer", (Type[])null, (Type[])null);

		private const float WaitTimeoutSeconds = 15f;

		private static IEnumerator WaitForClientThenInitialize(Player player, NetworkConnection owner)
		{
			float deadline = Time.realtimeSinceStartup + 15f;
			while (Time.realtimeSinceStartup < deadline)
			{
				if ((Object)(object)player == (Object)null)
				{
					_pending.Remove(player);
					yield break;
				}
				if (owner != (NetworkConnection)null && Client.Clients.ContainsKey(owner))
				{
					_pending.Remove(player);
					RunOriginal(player, owner);
					yield break;
				}
				yield return null;
			}
			_pending.Remove(player);
			Plugin.Log.LogError((object)($"[JoinFix] gave up after {15f:0}s waiting for the Client of connection " + ((owner == (NetworkConnection)null) ? "<null>" : owner.ClientId.ToString()) + ". That player will stay uninitialized, but the rest of the world still loaded."));
		}

		private static void RunOriginal(Player player, NetworkConnection owner)
		{
			if (InitializePlayerMethod == null)
			{
				Plugin.Log.LogError((object)"[JoinFix] Player.InitializePlayer not found — cannot finish deferred init.");
				return;
			}
			try
			{
				_reentering = true;
				InitializePlayerMethod.Invoke(player, null);
				Plugin.Log.LogInfo((object)$"[JoinFix] deferred InitializePlayer completed for connection {owner.ClientId}.");
			}
			catch (Exception ex)
			{
				Plugin.Log.LogError((object)$"[JoinFix] deferred InitializePlayer failed: {ex.InnerException ?? ex}");
			}
			finally
			{
				_reentering = false;
			}
		}
	}
	internal static class Kit
	{
		public static bool Aimbot;

		public static float AimFov = 80f;

		public static float AimRange = 300f;

		public static float AimSnap = 30f;

		public static float AimTurnRate = 720f;

		public static bool ManHunt;

		public static float ManFov = 90f;

		public static float ManSnap = 30f;

		public static bool Laser;

		private static bool _inShot;

		public static bool BunnyHop;

		private static float _lastHop;

		public static bool BossRush;

		public static string BossName = "Mutated";

		private static bool _fishing;

		private static Fishable _cachedBoss;

		private static float _lastScan = -999f;

		public static float WhaleDistance = 40f;

		private static Creature _whalePrefab;

		private const float LavaRange = 400f;

		public static bool Visibility;

		public static float FogMultiplier = 0.15f;

		public static float ViewDistance = 5000f;

		private static bool _fogCaptured;

		private static bool _fogWasOn;

		private static bool _visWasOn;

		private static bool _clipCaptured;

		private static float _fogDensity;

		private static float _origClip;

		public static bool UnlockSkins;

		private static bool _itemSkinsDone;

		private static float _nextSkinTry;

		public static string CasinoRarity = "off";

		public static bool Roulette;

		public static string RouletteColour = "green";

		public static bool DripperTakesAnything;

		public static float WorthMultiplier = 1000f;

		public static bool RevealIslands;

		public static bool UnlockTravel = true;

		private static bool _inDots;

		private static bool _inTravel;

		private static bool Muffle
		{
			get
			{
				if (_inShot)
				{
					return Laser;
				}
				return false;
			}
		}

		private static void ApplyAim(PlayerAimAssist aa)
		{
			float num = Mathf.Clamp(AimFov, 1f, 90f);
			float num2 = Mathf.Max(1f, AimRange);
			float num3 = Mathf.Min(num + 40f, 179f);
			float num4 = Mathf.Cos(num * (MathF.PI / 180f));
			Traverse obj = Traverse.Create((object)aa);
			obj.Field("_maxTargetDistance").SetValue((object)num2);
			obj.Field("_maxSqrTargetDistance").SetValue((object)(num2 * num2));
			obj.Field("_adsAcquireAngle").SetValue((object)num);
			obj.Field("_minAcquireAlignment").SetValue((object)num4);
			obj.Field("_acquireAlignmentRange").SetValue((object)Mathf.Max(1f - num4, Mathf.Epsilon));
			obj.Field("_trackingBreakAngle").SetValue((object)num3);
			obj.Field("_minTrackingAlignment").SetValue((object)Mathf.Cos(num3 * (MathF.PI / 180f)));
			obj.Field("_maxRotationSpeed").SetValue((object)AimTurnRate);
			obj.Field("_trackingSharpness").SetValue((object)AimSnap);
		}

		public static void AimCache_Post(PlayerAimAssist __instance)
		{
			try
			{
				if (Aimbot)
				{
					ApplyAim(__instance);
				}
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("[Kit] aim cache: " + ex.Message));
			}
		}

		public static void AimCanUse_Post(PlayerAimAssist __instance, ref bool __result)
		{
			try
			{
				if (Aimbot)
				{
					Player value = Traverse.Create((object)__instance).Field("_player").GetValue<Player>();
					if (!((Object)(object)value == (Object)null) && !value.BlockInputs && !((Object)(object)value.Camera == (Object)null) && value.Camera.MouseLocked)
					{
						ApplyAim(__instance);
						__result = true;
					}
				}
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("[Kit] aim gate: " + ex.Message));
			}
		}

		public static void AimAssist_Post(PlayerCamera __instance)
		{
			try
			{
				HuntFrame(__instance);
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("[Kit] manhunt: " + ex.Message));
			}
		}

		private static void HuntFrame(PlayerCamera cam)
		{
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: 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_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: 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_01c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d1: Unknown result type (might be due to invalid IL or missing references)
			//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_01df: 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_0212: 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_0233: Unknown result type (might be due to invalid IL or missing references)
			//IL_023a: Unknown result type (might be due to invalid IL or missing references)
			//IL_024d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0269: Unknown result type (might be due to invalid IL or missing references)
			//IL_014f: 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)
			//IL_0154: Unknown result type (might be due to invalid IL or missing references)
			//IL_0156: Unknown result type (might be due to invalid IL or missing references)
			//IL_0158: 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_015e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0172: 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)
			//IL_019e: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a0: Unknown result type (might be due to invalid IL or missing references)
			if (!ManHunt)
			{
				return;
			}
			Player localPlayer = Player.LocalPlayer;
			if ((Object)(object)localPlayer == (Object)null || localPlayer.BlockInputs || (Object)(object)Traverse.Create((object)cam).Field("_player").GetValue<Player>() != (Object)(object)localPlayer || (Object)(object)localPlayer.Camera == (Object)null || !localPlayer.Camera.MouseLocked)
			{
				return;
			}
			Item val = (((Object)(object)localPlayer.Holding != (Object)null) ? localPlayer.Holding.HeldItem : null);
			if ((Object)(object)val == (Object)null || (Object)(object)val.Weapon == (Object)null || !val.Weapon.IsAds)
			{
				return;
			}
			Vector3 position = cam.CamTransform.position;
			Traverse val2 = Traverse.Create((object)cam).Field("_rot");
			Vector3 value = val2.GetValue<Vector3>();
			Vector3 val3 = Quaternion.Euler(value) * Vector3.forward;
			float num = Mathf.Clamp(ManFov, 1f, 180f);
			Player val4 = null;
			float num2 = float.MaxValue;
			Vector3 val5 = Vector3.zero;
			foreach (Player alivePlayer in PlayerManager.AlivePlayers)
			{
				if ((Object)(object)alivePlayer == (Object)null || (Object)(object)alivePlayer == (Object)(object)localPlayer)
				{
					continue;
				}
				Vector3 val6 = (Object.op_Implicit((Object)(object)alivePlayer.Rigidbody) ? alivePlayer.Rigidbody.worldCenterOfMass : alivePlayer.Transform.position);
				Vector3 val7 = val6 - position;
				float magnitude = ((Vector3)(ref val7)).magnitude;
				if (magnitude < 0.01f)
				{
					continue;
				}
				float num3 = Vector3.Angle(val3, val7);
				if (!(num3 > num))
				{
					float num4 = num3 + magnitude * 0.01f;
					if (num4 < num2)
					{
						num2 = num4;
						val4 = alivePlayer;
						val5 = val6;
					}
				}
			}
			if (!((Object)(object)val4 == (Object)null))
			{
				Quaternion val8 = Quaternion.LookRotation(val5 - position, Vector3.up);
				Vector3 eulerAngles = ((Quaternion)(ref val8)).eulerAngles;
				float num5 = 1f - Mathf.Exp((0f - Mathf.Max(0.01f, ManSnap)) * Time.deltaTime);
				value.x += Mathf.DeltaAngle(value.x, eulerAngles.x) * num5;
				value.y += Mathf.DeltaAngle(value.y, eulerAngles.y) * num5;
				value.x = Mathf.Clamp(value.x, -90f, 90f);
				val2.SetValue((object)value);
			}
		}

		public static void Cooldown_Post(Weapon __instance, ref bool __result)
		{
			if (Laser && (Object)(object)__instance != (Object)null && Mine(__instance))
			{
				__result = false;
			}
		}

		public static void WeaponUpdate_Pre(Weapon __instance)
		{
			if (Laser && (Object)(object)__instance != (Object)null && Mine(__instance))
			{
				Traverse.Create((object)__instance).Field("_fullAuto").SetValue((object)true);
			}
		}

		public static void LaserShoot_Pre(Weapon __instance)
		{
			_inShot = Laser && (Object)(object)__instance != (Object)null && Mine(__instance);
		}

		public static void LaserShoot_Fin()
		{
			_inShot = false;
		}

		public static bool Kick_Pre()
		{
			return !Muffle;
		}

		private static bool Mine(Weapon w)
		{
			Player value = Traverse.Create((object)w).Field("_holder").GetValue<Player>();
			if ((Object)(object)value != (Object)null)
			{
				return (Object)(object)value == (Object)(object)Player.LocalPlayer;
			}
			return false;
		}

		private static void HopFrame()
		{
			if (!BunnyHop)
			{
				return;
			}
			Player localPlayer = Player.LocalPlayer;
			if (!((Object)(object)localPlayer == (Object)null) && !localPlayer.BlockInputs)
			{
				PlayerMovement movement = localPlayer.Movement;
				if (!((Object)(object)movement == (Object)null) && movement.Grounded && Input.GetKey((KeyCode)32) && !(Time.time - _lastHop < 0.1f))
				{
					movement.Jump();
					_lastHop = Time.time;
				}
			}
		}

		public static void FindFish_Pre()
		{
			_fishing = true;
		}

		public static void FindFish_Fin()
		{
			_fishing = false;
		}

		public static void BossRoll_Post(List<ItemInfoWeight> weights, ref Fishable __result)
		{
			if (!BossRush || !_fishing)
			{
				return;
			}
			try
			{
				if (Object.op_Implicit((Object)(object)BossManager.Boss))
				{
					return;
				}
			}
			catch
			{
				return;
			}
			Fishable val = FindBoss();
			if (!((Object)(object)val == (Object)null) && !((Object)(object)val.ItemToSpawn == (Object)null) && !((Object)(object)__result == (Object)(object)val))
			{
				__result = val;
				Plugin.Log.LogInfo((object)("[Kit] boss on the line: " + ((Object)val.ItemToSpawn).name));
			}
		}

		private static Fishable FindBoss()
		{
			if ((Object)(object)_cachedBoss != (Object)null && Time.time - _lastScan < 5f)
			{
				return _cachedBoss;
			}
			_lastScan = Time.time;
			string wanted = (BossName ?? "").Trim();
			if (wanted.Length == 0)
			{
				wanted = "Mutated";
			}
			try
			{
				_cachedBoss = (from f in Resources.FindObjectsOfTypeAll<Fishable>()
					where (Object)(object)f != (Object)null && (Object)(object)f.ItemToSpawn != (Object)null
					where ((Object)f.ItemToSpawn).name.IndexOf(wanted, StringComparison.OrdinalIgnoreCase) >= 0
					select f).FirstOrDefault();
			}
			catch
			{
				_cachedBoss = null;
			}
			return _cachedBoss;
		}

		public static List<string> BossNames()
		{
			try
			{
				return (from n in (from f in Resources.FindObjectsOfTypeAll<Fishable>()
						where (Object)(object)f != (Object)null && (Object)(object)f.ItemToSpawn != (Object)null
						select ((Object)f.ItemToSpawn).name).Distinct()
					where n.IndexOf("Whale", StringComparison.OrdinalIgnoreCase) >= 0 || n.IndexOf("Mutated", StringComparison.OrdinalIgnoreCase) >= 0 || n.IndexOf("Piranha", StringComparison.OrdinalIgnoreCase) >= 0 || n.IndexOf("Shark", StringComparison.OrdinalIgnoreCase) >= 0 || n.IndexOf("Squid", StringComparison.OrdinalIgnoreCase) >= 0 || n.IndexOf("Kraken", StringComparison.OrdinalIgnoreCase) >= 0
					orderby n
					select n).ToList();
			}
			catch
			{
				return new List<string>();
			}
		}

		public static void Lava_Post(MainLava __instance)
		{
			if ((Object)(object)_whalePrefab != (Object)null)
			{
				return;
			}
			try
			{
				Creature value = Traverse.Create((object)__instance).Field("_mutatedWhalePrefab").GetValue<Creature>();
				if (!((Object)(object)value == (Object)null))
				{
					_whalePrefab = value;
					Plugin.Log.LogInfo((object)("[Kit] cached " + ((Object)value).name + " - summonable from any island now."));
				}
			}
			catch
			{
			}
		}

		public static string SummonWhale()
		{
			//IL_004c: 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_0113: Unknown result type (might be due to invalid IL or missing references)
			//IL_0118: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: 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_0131: Unknown result type (might be due to invalid IL or missing references)
			//IL_0136: Unknown result type (might be due to invalid IL or missing references)
			//IL_013b: Unknown result type (might be due to invalid IL or missing references)
			//IL_014e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0150: Unknown result type (might be due to invalid IL or missing references)
			//IL_0152: Unknown result type (might be due to invalid IL or missing references)
			//IL_0157: Unknown result type (might be due to invalid IL or missing references)
			//IL_0172: Unknown result type (might be due to invalid IL or missing references)
			//IL_0178: Unknown result type (might be due to invalid IL or missing references)
			//IL_019b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a0: Unknown result type (might be due to invalid IL or missing references)
			if (!Plugin.IsHosting)
			{
				return "Spawning is server side - host or play solo.";
			}
			try
			{
				if (Object.op_Implicit((Object)(object)BossManager.Boss))
				{
					return "A boss is already up. Kill it first.";
				}
			}
			catch
			{
			}
			try
			{
				MainLava val = Object.FindAnyObjectByType<MainLava>();
				if ((Object)(object)val != (Object)null && (Object)(object)Player.LocalPlayer != (Object)null)
				{
					float num = Vector3.Distance(Body.Of(Player.LocalPlayer), ((Component)val).transform.position);
					if (num > 400f)
					{
						Plugin.Log.LogInfo((object)("[Kit] whale: " + num.ToString("0") + "m from the volcano, so spawning it here instead."));
						val = null;
					}
				}
				if ((Object)(object)val != (Object)null)
				{
					MethodInfo methodInfo = AccessTools.Method(typeof(MainLava), "SpawnMutatedWhale", (Type[])null, (Type[])null);
					if (methodInfo != null && methodInfo.Invoke(val, null) is IEnumerator enumerator)
					{
						((MonoBehaviour)val).StartCoroutine(enumerator);
						return "The volcano is erupting. Whale in about three seconds.";
					}
				}
			}
			catch
			{
			}
			if ((Object)(object)_whalePrefab == (Object)null)
			{
				return "The whale prefab lives on the lava island. Visit it once this session and it can be summoned anywhere after.";
			}
			Player localPlayer = Player.LocalPlayer;
			if ((Object)(object)localPlayer == (Object)null)
			{
				return "No local player to spawn in front of.";
			}
			try
			{
				Vector3 val2 = Body.Facing(localPlayer);
				Vector3 val3 = Body.Of(localPlayer) + val2 * Mathf.Max(5f, WhaleDistance);
				val3.y = WaterManager.WaterHeight;
				Creature val4 = Object.Instantiate<Creature>(_whalePrefab, val3, Quaternion.LookRotation(-val2));
				((NetworkBehaviour)Server.Instance).Spawn(((Component)val4).gameObject, (NetworkConnection)null, default(Scene));
				ManualLogSource log = Plugin.Log;
				string text = ((Vector3)(ref val3)).ToString("0.0");
				Vector3 val5 = Body.Of(localPlayer);
				log.LogInfo((object)("[Kit] whale at " + text + " - you are at " + ((Vector3)(ref val5)).ToString("0.0")));
				return "Magma whale, " + WhaleDistance.ToString("0") + "m ahead. Its attacks still aim at the lava island.";
			}
			catch (Exception ex)
			{
				return "Could not: " + ex.Message;
			}
		}

		public static void SetFog_Post()
		{
			CaptureFog();
			if (Visibility)
			{
				ApplyFog();
			}
		}

		private static void CaptureFog()
		{
			_fogDensity = RenderSettings.fogDensity;
			_fogWasOn = RenderSettings.fog;
			_fogCaptured = true;
		}

		private static void ApplyFog()
		{
			float num = Mathf.Clamp01(FogMultiplier);
			if (num <= 0f)
			{
				RenderSettings.fog = false;
				return;
			}
			RenderSettings.fog = _fogWasOn;
			RenderSettings.fogDensity = _fogDensity * num;
		}

		private static void VisibilityFrame()
		{
			if (Visibility)
			{
				if (!_fogCaptured)
				{
					CaptureFog();
				}
				ApplyFog();
				Camera curCamera = GameInfo.CurCamera;
				if ((Object)(object)curCamera != (Object)null && ViewDistance > 0f)
				{
					if (!_clipCaptured)
					{
						_origClip = curCamera.farClipPlane;
						_clipCaptured = true;
					}
					if (curCamera.farClipPlane < ViewDistance)
					{
						curCamera.farClipPlane = ViewDistance;
					}
				}
				_visWasOn = true;
			}
			else if (_visWasOn)
			{
				_visWasOn = false;
				if (_fogCaptured)
				{
					RenderSettings.fog = _fogWasOn;
					RenderSettings.fogDensity = _fogDensity;
				}
				Camera curCamera2 = GameInfo.CurCamera;
				if ((Object)(object)curCamera2 != (Object)null && _clipCaptured)
				{
					curCamera2.farClipPlane = _origClip;
				}
			}
		}

		public static void SkinAwake_Post()
		{
			_itemSkinsDone = false;
			UnlockClothing();
		}

		private static void SkinFrame()
		{
			if (UnlockSkins && !_itemSkinsDone && !(Time.time < _nextSkinTry))
			{
				_nextSkinTry = Time.time + 2f;
				UnlockItemSkins();
			}
		}

		public static string UnlockEverything()
		{
			UnlockSkins = true;
			_itemSkinsDone = false;
			int num = UnlockClothing();
			int num2 = UnlockItemSkins();
			if (num2 <= 0)
			{
				return "Unlocked " + num + " clothing. Item skins are not loaded yet - they will be picked up as soon as they are.";
			}
			return "Unlocked " + num + " clothing and " + num2 + " skins.";
		}

		private static int UnlockClothing()
		{
			int num = 0;
			try
			{
				string[] array = new string[3] { "_unlockedHats", "_unlockedOutfits", "_unlockedAccessories" };
				foreach (string text in array)
				{
					if (Traverse.Create(typeof(SkinManager)).Field(text).GetValue() is IList list)
					{
						num += list.Count;
					}
				}
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("[Kit] clothing: " + ex.Message));
			}
			return num;
		}

		private static int UnlockItemSkins()
		{
			int num = 0;
			try
			{
				Item[] availableItems = SlotMachine.AvailableItems;
				if (availableItems != null)
				{
					Item[] array = availableItems;
					foreach (Item val in array)
					{
						if ((Object)(object)val == (Object)null || (Object)(object)val.SkinPreset == (Object)null)
						{
							continue;
						}
						for (int j = 0; j < val.SkinPreset.Skins.Count; j++)
						{
							try
							{
								SaveManager.UnlockSkin(val.ID, (byte)j);
								num++;
							}
							catch
							{
							}
						}
					}
				}
				Boat boat = BoatManager.Boat;
				if ((Object)(object)boat != (Object)null && (Object)(object)boat.SkinPreset != (Object)null)
				{
					for (int k = 0; k < boat.SkinPreset.Skins.Count; k++)
					{
						try
						{
							SaveManager.UnlockSkin(byte.MaxValue, (byte)k);
							num++;
						}
						catch
						{
						}
					}
				}
				_itemSkinsDone = true;
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("[Kit] item skins: " + ex.Message));
			}
			if (num > 0)
			{
				_itemSkinsDone = true;
			}
			return num;
		}

		public unsafe static void Roll_Pre()
		{
			//IL_003d: 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_0043: Unknown result type (might be due to invalid IL or missing references)
			string text = (CasinoRarity ?? "").Trim();
			if (text.Length == 0 || text.Equals("off", StringComparison.OrdinalIgnoreCase))
			{
				try
				{
					SlotMachineManager.SetCheatSkin((Item)null, byte.MaxValue);
					return;
				}
				catch
				{
					return;
				}
			}
			Rarity target = ResolveRarity(text);
			if (!PickSkin(target, out var item, out var skinIndex))
			{
				Plugin.Log.LogWarning((object)("[Kit] no " + ((object)(*(Rarity*)(&target))/*cast due to .constrained prefix*/).ToString() + " skin to force this roll."));
				return;
			}
			try
			{
				SlotMachineManager.SetCheatSkin(item, skinIndex);
			}
			catch
			{
			}
		}

		private static Rarity ResolveRarity(string mode)
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			if (mode.Equals("legendary", StringComparison.OrdinalIgnoreCase))
			{
				return (Rarity)3;
			}
			if (mode.Equals("rare", StringComparison.OrdinalIgnoreCase))
			{
				return (Rarity)2;
			}
			if (mode.Equals("common", StringComparison.OrdinalIgnoreCase))
			{
				return (Rarity)1;
			}
			return Greenest();
		}

		private static Rarity Greenest()
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: 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_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			Rarity best = (Rarity)2;
			float bestScore = float.NegativeInfinity;
			try
			{
				Consider((Rarity)1, GameInfo.CommonColor);
				Consider((Rarity)2, GameInfo.RareColor);
				Consider((Rarity)3, GameInfo.LegendaryColor);
			}
			catch
			{
			}
			return best;
			void Consider(Rarity r, Color c)
			{
				//IL_0000: 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_000c: 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_002b: Unknown result type (might be due to invalid IL or missing references)
				float num = c.g - Mathf.Max(c.r, c.b);
				if (num > bestScore)
				{
					bestScore = num;
					best = r;
				}
			}
		}

		private static bool PickSkin(Rarity target, out Item item, out byte skinIndex)
		{
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: 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)
			item = null;
			skinIndex = byte.MaxValue;
			try
			{
				List<Item> list = new List<Item>();
				if (SlotMachine.AvailableItems != null)
				{
					list.AddRange(SlotMachine.AvailableItems);
				}
				if (!SlotMachine.ExcludeBoat)
				{
					list.Add(null);
				}
				foreach (Item item2 in list)
				{
					SkinPreset val = (((Object)(object)item2 != (Object)null) ? item2.SkinPreset : (((Object)(object)BoatManager.Boat != (Object)null) ? BoatManager.Boat.SkinPreset : null));
					if ((Object)(object)val == (Object)null)
					{
						continue;
					}
					for (int i = 0; i < val.Skins.Count; i++)
					{
						ItemSkin val2 = val.Skins[i];
						if (((ItemSkin)(ref val2)).Rarity == target)
						{
							item = item2;
							skinIndex = (byte)i;
							return true;
						}
					}
				}
			}
			catch
			{
			}
			return false;
		}

		public static string CycleCasino()
		{
			string text = (CasinoRarity ?? "").Trim().ToLowerInvariant();
			if (!(text == "off") && (text == null || text.Length != 0))
			{
				if (!(text == "green"))
				{
					if (text == "rare")
					{
						CasinoRarity = "legendary";
					}
					else
					{
						CasinoRarity = "off";
					}
				}
				else
				{
					CasinoRarity = "rare";
				}
			}
			else
			{
				CasinoRarity = "green";
			}
			if (CasinoRarity == "off")
			{
				try
				{
					SlotMachineManager.SetCheatSkin((Item)null, byte.MaxValue);
				}
				catch
				{
				}
			}
			return "Dripper rigged: " + CasinoLabel();
		}

		public static string CasinoLabel()
		{
			//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)
			string text = (CasinoRarity ?? "").Trim();
			if (text.Length == 0)
			{
				return "off";
			}
			if (text.Equals("green", StringComparison.OrdinalIgnoreCase))
			{
				return "green (" + ((object)Greenest()/*cast due to .constrained prefix*/).ToString() + ")";
			}
			return text.ToLowerInvariant();
		}

		public static void Roulette_Post(ref BetColor __result)
		{
			//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_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Invalid comparison between I4 and Unknown
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Expected I4, but got Unknown
			if (Roulette)
			{
				BetColor val = ResolveColour(RouletteColour);
				if ((int)__result != (int)val)
				{
					__result = (BetColor)(int)val;
				}
			}
		}

		private static BetColor ResolveColour(string name)
		{
			name = (name ?? "").Trim();
			if (!name.Equals("black", StringComparison.OrdinalIgnoreCase))
			{
				if (!name.Equals("red", StringComparison.OrdinalIgnoreCase))
				{
					return (BetColor)2;
				}
				return (BetColor)1;
			}
			return (BetColor)0;
		}

		public static string CycleRoulette()
		{
			string text = (RouletteColour ?? "").Trim().ToLowerInvariant();
			if (!Roulette)
			{
				Roulette = true;
				RouletteColour = "green";
			}
			else if (text == "green")
			{
				RouletteColour = "red";
			}
			else if (text == "red")
			{
				RouletteColour = "black";
			}
			else
			{
				Roulette = false;
			}
			return "Roulette: " + RouletteLabel();
		}

		public static string RouletteLabel()
		{
			if (!Roulette)
			{
				return "off";
			}
			return RouletteColour;
		}

		public static bool Dripper_Pre(Collider other)
		{
			if (!DripperTakesAnything)
			{
				return true;
			}
			try
			{
				if ((Object)(object)Server.Instance == (Object)null || !((NetworkBehaviour)Server.Instance).IsServerInitialized)
				{
					return false;
				}
				if (SlotMachine.IsRolling)
				{
					return false;
				}
				Item val = ItemManager.Get(other);
				if ((Object)(object)val == (Object)null || (Object)(object)val.Holder != (Object)null)
				{
					return false;
				}
				if ((Object)(object)val.Creature != (Object)null && !val.Creature.IsDead)
				{
					return false;
				}
				Player val2 = (((Object)(object)val.Holder != (Object)null) ? val.Holder : val.LastHolder);
				if ((Object)(object)val2 == (Object)null)
				{
					return false;
				}
				val.DestroyItem((byte)4, byte.MaxValue);
				SlotMachineManager.RollRandom(val2);
			}
			catch
			{
			}
			return false;
		}

		private static float WorthOf(Item item)
		{
			try
			{
				Traverse val = Traverse.Create((object)item).Field("_worth");
				if (val != null && val.FieldExists())
				{
					return val.GetValue<float>();
				}
			}
			catch
			{
			}
			return -1f;
		}

		public static string InflateHeld()
		{
			if (!Plugin.IsHosting)
			{
				Plugin.Log.LogInfo((object)"[Kit] inflate: not hosting.");
				return "Worth is server side - host or play solo.";
			}
			Player localPlayer = Player.LocalPlayer;
			if ((Object)(object)localPlayer == (Object)null || (Object)(object)Server.Instance == (Object)null)
			{
				Plugin.Log.LogInfo((object)("[Kit] inflate: player=" + (((Object)(object)localPlayer == (Object)null) ? "null" : "ok") + " server=" + (((Object)(object)Server.Instance == (Object)null) ? "null" : "ok")));
				return "Not connected.";
			}
			List<Item> list = Carried(localPlayer);
			if (list.Count == 0)
			{
				Plugin.Log.LogInfo((object)("[Kit] inflate: nothing carried - holder=" + (((Object)(object)localPlayer.Holding == (Object)null) ? "null" : (((Object)(object)localPlayer.Holding.HeldItem == (Object)null) ? "empty" : "ok"))));
				return "You are not carrying anything to inflate.";
			}
			float num = Mathf.Clamp(WorthMultiplier, 1f, 100000f);
			int num2 = 0;
			int num3 = 0;
			string text = null;
			foreach (Item item in list)
			{
				float num4 = WorthOf(item);
				try
				{
					Server.Instance.SetItemMultiplier(item, num);
				}
				catch (Exception ex)
				{
					if (text == null)
					{
						text = ex.Message;
					}
					Plugin.Log.LogWarning((object)("[Kit] inflate threw on " + ((Object)item).name + ": " + ex.Message));
					continue;
				}
				float num5 = WorthOf(item);
				Plugin.Log.LogInfo((object)("[Kit] inflate " + ((Object)item).name + " x" + num.ToString("0") + "  worth " + num4.ToString("0") + " -> " + num5.ToString("0")));
				if (num4 >= 0f && num5 >= 0f && Mathf.Approximately(num4, num5))
				{
					num3++;
				}
				else
				{
					num2++;
				}
			}
			if (text != null && num2 == 0)
			{
				return "SetItemMultiplier threw: " + text;
			}
			if (num2 == 0)
			{
				return "Nothing changed - the server took the call and ignored it for all " + list.Count + " item(s). Check the log.";
			}
			return "Inflated " + num2 + " of " + list.Count + " item(s) x" + num.ToString("0") + ((num3 > 0) ? (". " + num3 + " would not take - already inflated, probably.") : ".") + " Sell them now.";
		}

		private static List<Item> Carried(Player me)
		{
			List<Item> list = new List<Item>();
			try
			{
				Item val = (((Object)(object)me.Holding != (Object)null) ? me.Holding.HeldItem : null);
				if ((Object)(object)val != (Object)null)
				{
					list.Add(val);
				}
			}
			catch
			{
			}
			try
			{
				object value = Traverse.Create((object)me).Property("Inventory", (object[])null).GetValue();
				if (value == null)
				{
					value = Traverse.Create((object)me).Field("_inventory").GetValue();
				}
				if (value == null)
				{
					return list;
				}
				IEnumerable enumerable = (Traverse.Create(value).Property("Items", (object[])null).GetValue() as IEnumerable) ?? (Traverse.Create(value).Field("_slots").GetValue() as IEnumerable);
				if (enumerable == null)
				{
					Plugin.Log.LogInfo((object)"[Kit] inflate: found an inventory with no Items or _slots to read.");
					return list;
				}
				foreach (object item in enumerable)
				{
					if (item != null)
					{
						Item val2 = (Item)((item is Item) ? item : null);
						if ((Object)(object)val2 == (Object)null)
						{
							Traverse val3 = Traverse.Create(item);
							object value2 = val3.Property("Item", (object[])null).GetValue();
							val2 = (Item)(((value2 is Item) ? value2 : null) ?? ((object)/*isinst with value type is only supported in some contexts*/));
						}
						if ((Object)(object)val2 != (Object)null && !list.Contains(val2))
						{
							list.Add(val2);
						}
					}
				}
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("[Kit] inflate: could not read the inventory: " + ex.Message));
			}
			return list;
		}

		public static void Radar_Pre(RadarUI __instance)
		{
			if (!RevealIslands)
			{
				return;
			}
			try
			{
				Traverse obj = Traverse.Create((object)__instance);
				obj.Field("_isOn").SetValue((object)true);
				CanvasGroup value = obj.Field("_canvasGroup").GetValue<CanvasGroup>();
				if ((Object)(object)value != (Object)null)
				{
					value.alpha = 1f;
				}
			}
			catch
			{
			}
		}

		public static void Dots_Pre()
		{
			_inDots = true;
		}

		public static void Dots_Fin()
		{
			_inDots = false;
		}

		public static void Travel_Pre()
		{
			_inTravel = true;
		}

		public static void Travel_Fin()
		{
			_inTravel = false;
		}

		public static void MaxIsland_Post(ref byte __result)
		{
			if (!RevealIslands || (!_inDots && (!_inTravel || !UnlockTravel)))
			{
				return;
			}
			try
			{
				int num = Mathf.Clamp(IslandManager.TotalIslands, 0, 255);
				if (num > __result)
				{
					__result = (byte)num;
				}
			}
			catch
			{
			}
		}

		public static void Tick()
		{
			try
			{
				HopFrame();
			}
			catch
			{
			}
			try
			{
				VisibilityFrame();
			}
			catch
			{
			}
			try
			{
				SkinFrame();
			}
			catch
			{
			}
		}

		public static void Install(Harmony h)
		{
			//IL_02b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c2: Expected O, but got Unknown
			Patch(typeof(PlayerAimAssist), "CacheSettings", null, "AimCache_Post");
			Patch(typeof(PlayerAimAssist), "CanUseAimAssist", null, "AimCanUse_Post");
			Patch(typeof(PlayerCamera), "ApplyAimAssist", null, "AimAssist_Post");
			Patch(typeof(Weapon), "HasCooldown", null, "Cooldown_Post");
			Patch(typeof(Weapon), "Update", "WeaponUpdate_Pre");
			Patch(typeof(Weapon), "Shoot", "LaserShoot_Pre", null, "LaserShoot_Fin");
			Patch(typeof(Weapon), "AddModelRecoil", "Kick_Pre");
			Patch(typeof(PlayerToolMovement), "Recoil", "Kick_Pre");
			Patch(typeof(PlayerCamera), "Recoil", "Kick_Pre");
			Patch(typeof(PlayerMovement), "Knockback", "Kick_Pre");
			Patch(typeof(CreatureManager), "FindFishForBait", "FindFish_Pre", null, "FindFish_Fin");
			Patch(typeof(CreatureManager), "GetRandomItem", null, "BossRoll_Post");
			Patch(typeof(MainLava), "Awake", null, "Lava_Post");
			Patch(typeof(ShaderManager), "SetFog", null, "SetFog_Post");
			Patch(typeof(SkinManager), "Awake", null, "SkinAwake_Post");
			Patch(typeof(SlotMachineManager), "RollRandom", "Roll_Pre");
			Patch(typeof(LocalCasino), "GetRouletteColorFromBall", null, "Roulette_Post");
			Patch(typeof(SlotMachine), "OnTriggerStay", "Dripper_Pre");
			Patch(typeof(RadarUI), "Update", "Radar_Pre");
			Patch(typeof(RadarUI), "UpdateIslandDots", "Dots_Pre", null, "Dots_Fin");
			Patch(typeof(IslandSpawner), "OnTriggerEnter", "Travel_Pre", null, "Travel_Fin");
			try
			{
				MethodInfo methodInfo = AccessTools.PropertyGetter(typeof(OnlineIslandManager), "MaxIslandUnlocked");
				if (methodInfo != null)
				{
					h.Patch((MethodBase)methodInfo, (HarmonyMethod)null, new HarmonyMethod(AccessTools.Method(typeof(Kit), "MaxIsland_Post", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				}
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("[Kit] MaxIslandUnlocked: " + ex.Message));
			}
			Plugin.Log.LogWarning((object)"[Kit] the rest of Ender's Tweaks is loaded. Private build only.");
			void Patch(Type type, string method, string pre = null, string post = null, string fin = null)
			{
				//IL_006f: Unknown result type (might be due to invalid IL or missing references)
				//IL_008c: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
				try
				{
					MethodInfo methodInfo2 = AccessTools.Method(type, method, (Type[])null, (Type[])null);
					if (methodInfo2 == null)
					{
						Plugin.Log.LogWarning((object)("[Kit] " + type.Name + "." + method + " not found"));
					}
					else
					{
						h.Patch((MethodBase)methodInfo2, (pre == null) ? ((HarmonyMethod)null) : new HarmonyMethod(AccessTools.Method(typeof(Kit), pre, (Type[])null, (Type[])null)), (post == null) ? ((HarmonyMethod)null) : new HarmonyMethod(AccessTools.Method(typeof(Kit), post, (Type[])null, (Type[])null)), (HarmonyMethod)null, (fin == null) ? ((HarmonyMethod)null) : new HarmonyMethod(AccessTools.Method(typeof(Kit), fin, (Type[])null, (Type[])null)), (HarmonyMethod)null);
					}
				}
				catch (Exception ex2)
				{
					Plugin.Log.LogWarning((object)("[Kit] " + method + ": " + ex2.Message));
				}
			}
		}
	}
	internal static class Lobby
	{
		private static int _applied;

		public static int Applied => _applied;

		public static string Widen()
		{
			int num = ((Plugin.LobbySize != null) ? Plugin.LobbySize.Value : 0);
			if (num <= 0)
			{
				Plugin.Log.LogInfo((object)"[Lobby] MaxPlayers is 0, so the lobby holds whatever the game says. Raise it in the console under Warden, or set Lobby/MaxPlayers in the config.");
				return null;
			}
			if (!Plugin.IsHosting)
			{
				return "Only the host decides how big the lobby is.";
			}
			string text = "";
			try
			{
				NetworkManager val = Object.FindAnyObjectByType<NetworkManager>();
				ServerManager val2 = (((Object)(object)val != (Object)null) ? val.ServerManager : null);
				if ((Object)(object)val2 != (Object)null)
				{
					MethodInfo methodInfo = AccessTools.Method(((object)val2).GetType(), "SetMaximumClients", (Type[])null, (Type[])null);
					if (methodInfo != null)
					{
						methodInfo.Invoke(val2, new object[1] { num });
						text += "FishNet ";
					}
					else
					{
						Plugin.Log.LogWarning((object)"[Lobby] no SetMaximumClients on the server manager.");
					}
				}
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("[Lobby] FishNet cap: " + ex.Message));
			}
			try
			{
				int num2 = 0;
				Type[] types = typeof(Player).Assembly.GetTypes();
				foreach (Type type in types)
				{
					if (type == null || type.IsNested)
					{
						continue;
					}
					string[] array = new string[3] { "MaxPlayers", "maxPlayers", "_maxPlayers" };
					foreach (string text2 in array)
					{
						FieldInfo fieldInfo = AccessTools.Field(type, text2);
						if (fieldInfo == null || fieldInfo.FieldType != typeof(int))
						{
							continue;
						}
						if (fieldInfo.IsStatic)
						{
							fieldInfo.SetValue(null, num);
							num2++;
							continue;
						}
						Object val3 = Object.FindAnyObjectByType(type);
						if (val3 != (Object)null)
						{
							fieldInfo.SetValue(val3, num);
							num2++;
						}
					}
				}
				if (num2 > 0)
				{
					text = text + num2 + " game field(s, may be inert) ";
				}
			}
			catch (Exception ex2)
			{
				Plugin.Log.LogWarning((object)("[Lobby] game field: " + ex2.Message));
			}
			if (Steam(num))
			{
				text += "Steam ";
			}
			_applied = num;
			string text3 = (string.IsNullOrEmpty(text) ? "Could not find anything to raise - the lobby size is unchanged." : ("Lobby raised to " + num + " (" + text.Trim() + ")."));
			Plugin.Log.LogInfo((object)("[Lobby] " + text3));
			return text3;
		}

		private static bool Steam(int want)
		{
			try
			{
				Assembly assembly = AppDomain.CurrentDomain.GetAssemblies().FirstOrDefault((Assembly a) => a.GetName().Name.IndexOf("steamworks", StringComparison.OrdinalIgnoreCase) >= 0);
				if (assembly == null)
				{
					return false;
				}
				Type type = assembly.GetTypes().FirstOrDefault((Type t) => t.Name == "SteamMatchmaking");
				MethodInfo methodInfo = ((type != null) ? AccessTools.Method(type, "SetLobbyMemberLimit", (Type[])null, (Type[])null) : null);
				if (methodInfo == null)
				{
					return false;
				}
				object obj = null;
				Type[] types = typeof(Player).Assembly.GetTypes();
				foreach (Type type2 in types)
				{
					if (type2 == null || type2.IsNested)
					{
						continue;
					}
					string[] array = new string[3] { "CurrentLobbyID", "LobbyID", "LobbyId" };
					foreach (string text in array)
					{
						PropertyInfo propertyInfo = AccessTools.Property(type2, text);
						if (propertyInfo == null || propertyInfo.GetMethod == null)
						{
							continue;
						}
						Object val = (propertyInfo.GetMethod.IsStatic ? null : Object.FindAnyObjectByType(type2));
						if (propertyInfo.GetMethod.IsStatic || !(val == (Object)null))
						{
							object value = propertyInfo.GetValue(val);
							if (value != null)
							{
								obj = value;
								break;
							}
						}
					}
					if (obj != null)
					{
						break;
					}
					array = new string[5] { "<CurrentLobbyID>k__BackingField", "m_steamIDLobby", "m_ulSteamIDLobby", "_lobbyId", "LobbyId" };
					foreach (string text2 in array)
					{
						FieldInfo fieldInfo = AccessTools.Field(type2, text2);
						if (fieldInfo == null)
						{
							continue;
						}
						Object val2 = (fieldInfo.IsStatic ? null : Object.FindAnyObjectByType(type2));
						if (fieldInfo.IsStatic || !(val2 == (Object)null))
						{
							object value2 = fieldInfo.GetValue(val2);
							if (value2 != null)
							{
								obj = value2;
								break;
							}
						}
					}
					if (obj != null)
					{
						break;
					}
				}
				if (obj == null)
				{
					Plugin.Log.LogWarning((object)"[Lobby] no lobby id to resize.");
					return false;
				}
				ParameterInfo[] parameters = methodInfo.GetParameters();
				if (parameters.Length != 2 || !parameters[0].ParameterType.IsInstanceOfType(obj))
				{
					return false;
				}
				object obj2 = methodInfo.Invoke(null, new object[2] { obj, want });
				Plugin.Log.LogInfo((object)("[Lobby] SetLobbyMemberLimit(" + want + ") returned " + obj2));
				return true;
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("[Lobby] Steam limit: " + ex.Message));
				return false;
			}
		}
	}
	internal sealed class Entry
	{
		public DateTime When;

		public string Who;

		public ulong Key;

		public string Rpc;

		public Verdict Verdict;

		public bool Blocked;

		public string Shot;

		public string Line => When.ToString("HH:mm:ss", CultureInfo.InvariantCulture) + "  [" + Verdict.Tag + "]  " + Who + "  " + Rpc + "  " + Verdict.Detail + (Blocked ? "  (blocked)" : "") + ((Shot != null) ? ("  [" + Shot + "]") : "");
	}
	internal static class Logbook
	{
		private static readonly List<Entry> _entries = new List<Entry>(512);

		private static readonly Dictionary<ulong, int> _strikes = new Dictionary<ulong, int>();

		private static readonly Dictionary<ulong, string> _names = new Dictionary<ulong, string>();

		private static string _file;

		private static readonly object _gate = new object();

		public static IReadOnlyList<Entry> Entries => _entries;

		public static string FilePath => _file;

		public static string Folder => Path.GetFullPath(Path.Combine(Paths.ConfigPath, "..", "Fishwarden"));

		public static void BeginSession()
		{
			try
			{
				Directory.CreateDirectory(Folder);
				string text = DateTime.Now.ToString("yyyy-MM-dd_HHmmss", CultureInfo.InvariantCulture);
				_file = Path.Combine(Folder, "poachers-log_" + text + ".txt");
				File.WriteAllText(_file, "Fishwarden 2.0.0 - Poacher's Log" + Environment.NewLine + "Session opened " + DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss", CultureInfo.InvariantCulture) + Environment.NewLine + "Level at open: " + Policy.Spell() + Environment.NewLine + new string('-', 72) + Environment.NewLine);
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("[Logbook] could not open a log file: " + ex.Message + " - keeping findings in memory only."));
				_file = null;
			}
		}

		public static Entry Record(NetworkConnection conn, string rpc, Verdict v, bool blocked)
		{
			ulong key = Sender.KeyOf(conn);
			string text = Sender.NameOf(conn);
			Rules.Note(v.Rule);
			Entry entry = new Entry
			{
				When = DateTime.Now,
				Who = text,
				Key = key,
				Rpc = rpc,
				Verdict = v,
				Blocked = blocked
			};
			lock (_gate)
			{
				_entries.Add(entry);
				_names[key] = text;
				_strikes.TryGetValue(key, out var value);
				_strikes[key] = value + v.StrikeWeight;
			}
			Plugin.Log.LogWarning((object)("[Fishwarden] " + entry.Line));
			Append(entry.Line);
			return entry;
		}

		public static void AttachShot(Entry e, string shot)
		{
			if (e != null)
			{
				e.Shot = shot;
				Append("           evidence: " + shot);
			}
		}

		private static void Append(string line)
		{
			if (_file == null)
			{
				return;
			}
			try
			{
				File.AppendAllText(_file, line + Environment.NewLine);
			}
			catch
			{
			}
		}

		public static int StrikesFor(NetworkConnection conn)
		{
			ulong key = Sender.KeyOf(conn);
			lock (_gate)
			{
				int value;
				return _strikes.TryGetValue(key, out value) ? value : 0;
			}
		}

		public static void Pardon(ulong key)
		{
			lock (_gate)
			{
				_strikes.Remove(key);
			}
			Append("           PARDONED " + Name(key) + " - strikes cleared by host");
		}

		public static string Name(ulong key)
		{
			lock (_gate)
			{
				string value;
				return _names.TryGetValue(key, out value) ? value : ("#" + key);
			}
		}

		public static Dictionary<ulong, int> Tally()
		{
			lock (_gate)
			{
				return new Dictionary<ulong, int>(_strikes);
			}
		}

		public static List<Entry> Tail(int n)
		{
			lock (_gate)
			{
				int num = Math.Max(0, _entries.Count - n);
				return _entries.GetRange(num, _entries.Count - num);
			}
		}

		public static List<string> ShotsFor(ulong key)
		{
			lock (_gate)
			{
				return (from e in _entries
					where e.Key == key && e.Shot != null
					select e.Shot).Distinct().ToList();
			}
		}

		public static List<Entry> EntriesFor(ulong key, int max)
		{
			lock (_gate)
			{
				List<Entry> list = _entries.Where((Entry e) => e.Key == key).ToList();
				int num = Math.Max(0, list.Count - max);
				return list.GetRange(num, list.Count - num);
			}
		}

		public static string Report()
		{
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.AppendLine("Fishwarden 2.0.0 - session report");
			stringBuilder.AppendLine("Generated " + DateTime.Now.ToString("yyyy-MM-dd HH:mm", CultureInfo.InvariantCulture));
			stringBuilder.AppendLine();
			Dictionary<ulong, int> dictionary = Tally();
			if (dictionary.Count == 0)
			{
				stringBuilder.AppendLine("No findings. Clean session.");
				return stringBuilder.ToString();
			}
			stringBuilder.AppendLine("Strikes by player:");
			foreach (KeyValuePair<ulong, int> item in dictionary)
			{
				stringBuilder.AppendLine($"  {Name(item.Key),-24} {item.Value}");
			}
			stringBuilder.AppendLine();
			stringBuilder.AppendLine("What people were doing:");
			foreach (string item2 in Summary.Lines(includeClean: false))
			{
				stringBuilder.AppendLine("  " + item2);
			}
			stringBuilder.AppendLine();
			stringBuilder.AppendLine("Findings:");
			lock (_gate)
			{
				foreach (Entry entry in _entries)
				{
					stringBuilder.AppendLine("  " + entry.Line);
				}
			}
			return stringBuilder.ToString();
		}
	}
	internal static class Movement
	{
		private sealed class Track
		{
			public Vector3 LastPos;

			public float LastTime;

			public int OverSpeed;

			public float LastFinding = -999f;

			public bool Primed;

			public Traverse WalkSpeed;

			public Traverse SprintSpeed;
		}

		private static readonly Dictionary<Player, Track> _tracks = new Dictionary<Player, Track>();

		private static float _nextTick;

		public static void Tick()
		{
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			if (!Plugin.IsHosting || !Plugin.WatchMovement.Value)
			{
				return;
			}
			float realtimeSinceStartup = Time.realtimeSinceStartup;
			if (realtimeSinceStartup < _nextTick)
			{
				return;
			}
			_nextTick = realtimeSinceStartup + Plugin.MovementSampleInterval.Value;
			try
			{
				foreach (Player player in PlayerManager.Players)
				{
					if ((Object)(object)player == (Object)null || (Object)(object)player == (Object)(object)Player.LocalPlayer)
					{
						continue;
					}
					NetworkConnection owner = ((NetworkBehaviour)player).Owner;
					if (!Sender.IsTrusted(owner))
					{
						try
						{
							Judge(player, Body.Of(player), owner);
						}
						catch
						{
						}
					}
				}
			}
			catch
			{
			}
		}

		private static void Judge(Player p, Vector3 pos, NetworkConnection conn)
		{
			//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)
			//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_0030: 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_007d: 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_0095: Unknown result type (might be due to invalid IL or missing references)
			if (!_tracks.TryGetValue(p, out var value))
			{
				value = new Track();
				_tracks[p] = value;
			}
			float realtimeSinceStartup = Time.realtimeSinceStartup;
			if (!value.Primed)
			{
				value.LastPos = pos;
				value.LastTime = realtimeSinceStartup;
				value.Primed = true;
				return;
			}
			float num = realtimeSinceStartup - value.LastTime;
			value.LastTime = realtimeSinceStartup;
			Vector3 lastPos = value.LastPos;
			value.LastPos = pos;
			if (num < 0.03f || num > 1f)
			{
				value.OverSpeed = 0;
				return;
			}
			Vector3 val = default(Vector3);
			((Vector3)(ref val))..ctor(pos.x - lastPos.x, 0f, pos.z - lastPos.z);
			float num2 = ((Vector3)(ref val)).magnitude / num;
			float num3 = CeilingFor(p, value) * Mathf.Max(1f, Plugin.SlackLine.Value);
			if (num3 > 0f && num2 > num3)
			{
				value.OverSpeed++;
				if (value.OverSpeed >= Plugin.SpeedSamples.Value && Ready(value, realtimeSinceStartup))
				{
					value.LastFinding = realtimeSinceStartup;
					value.OverSpeed = 0;
					Guard.Report(conn, "UpdatePlayerPosRot", Verdict.Strong("speed", $"moving at {num2:0} u/s over {Plugin.SpeedSamples.Value} samples (ceiling {num3:0} incl. slack)"));
				}
			}
			else
			{
				value.OverSpeed = 0;
			}
		}

		private static bool Ready(Track t, float now)
		{
			return now - t.LastFinding >= Plugin.MovementFindingCooldown.Value;
		}

		private static float CeilingFor(Player p, Track t)
		{
			try
			{
				PlayerMovement movement = p.Movement;
				if ((Object)(object)movement == (Object)null)
				{
					return Plugin.FallbackSpeedCeiling.Value;
				}
				if (t.SprintSpeed == null)
				{
					t.SprintSpeed = Traverse.Create((object)movement).Field("_sprintSpeed");
					t.WalkSpeed = Traverse.Create((object)movement).Field("_walkSpeed");
				}
				float num = ((t.SprintSpeed != null && t.SprintSpeed.FieldExists()) ? t.SprintSpeed.GetValue<float>() : 0f);
				if (num > 0.01f)
				{
					return num;
				}
			}
			catch
			{
			}
			return Plugin.FallbackSpeedCeiling.Value;
		}

		public static void Forget(Player p)
		{
			if (!((Object)(object)p == (Object)null))
			{
				_tracks.Remove(p);
			}
		}

		public static void Reset()
		{
			_tracks.Clear();
		}
	}
	internal static class MuteLines
	{
		public enum Reason
		{
			General,
			Swearing,
			Racism,
			Antisemitism,
			Political,
			Shouting
		}

		private static readonly string[] General = new string[4] { "{0} is making noises again. The fish have stopped biting.", "Something is mumbling near {0}. Nobody can make it out.", "{0} appears to be talking. The wind takes it.", "A sound comes from {0}'s direction. It is not words." };

		private static readonly string[] Swearing = new string[4] { "sorry, I can't speak right now. Mum put chilli powder on my tongue for saying bad words. It BURRRRNS", "rinsing my mouth out, this may take a while", "looking for some different words. still looking", "turns out I know a lot of words and only some of them are allowed" };

		private static readonly string[] Racism = new string[4] { "hey guys, I really struggle with racism and I am working on myself", "I am on a journey. it is going badly but I am on it", "my views are under review. so am I", "I have enrolled myself in a course. attendance is mandatory" };

		private static readonly string[] Antisemitism = new string[3] { "the Holocaust was a terrible tragedy and I hope we never see anything like it again", "I have reconsidered and I would like to apologise properly", "that was indefensible and I am not going to try to defend it" };

		private static readonly string[] Political = new string[4] { "I am here to fish and I have decided to do only that", "nobody came to this dock for my opinions", "I am going to keep it to the fish from now on", "you know what, not the time, not the place, not the lake" };

		private static readonly string[] Shouting = new string[3] { "I found my indoor voice, it was behind the sofa", "I am aware of the volume. I am working on the volume", "taking it down several notches, my apologies" };

		private static int _pick;

		public static string Name(Reason r)
		{
			return r switch
			{
				Reason.Swearing => "swearing", 
				Reason.Racism => "racism", 
				Reason.Antisemitism => "antisemitism", 
				Reason.Political => "politics", 
				Reason.Shouting => "shouting", 
				_ => "noise", 
			};
		}

		public static string For(Reason r, string who)
		{
			string[] array = Set(r);
			return string.Format(array[_pick++ % array.Length], who);
		}

		private static string[] Set(Reason r)
		{
			return r switch
			{
				Reason.Swearing => Swearing, 
				Reason.Racism => Racism, 
				Reason.Antisemitism => Antisemitism, 
				Reason.Political => Political, 
				Reason.Shouting => Shouting, 
				_ => General, 
			};
		}
	}
	internal static class NativeAudit
	{
		private const int FaultLimit = 40;

		private const int LineLimit = 800;

		private const int HitLimit = 60;

		private static GameObject _pending;

		private static string _tag;

		private static int _wait;

		private static int _lines;

		private static readonly Vector3[] _corners = (Vector3[])(object)new Vector3[4];

		public static void Request(GameObject root, string tag)
		{
			_pending = root;
			_tag = tag;
			_wait = 2;
		}

		public static void Tick()
		{
			if ((Object)(object)_pending == (Object)null || _wait-- > 0)
			{
				return;
			}
			GameObject pending = _pending;
			_pending = null;
			if ((Object)(object)pending == (Object)null)
			{
				return;
			}
			try
			{
				Canvas.ForceUpdateCanvases();
				Report(pending, _tag);
			}
			catch (Exception ex)
			{
				Plugin.Log.LogError((object)("[Audit] could not measure: " + ex));
			}
		}

		private static void Report(GameObject root, string tag)
		{
			List<string> list = new List<string>();
			Plugin.Log.LogInfo((object)("[Audit] ---- " + tag + " ----"));
			Plugin.Log.LogInfo((object)("[Audit] screen " + Screen.width + "x" + Screen.height + Canvasing(root)));
			Plugin.Log.LogInfo((object)"[Audit] name  [screen x,y w,h]  layout  |  components");
			_lines = 0;
			Walk(root.transform, 0, list);
			if (_lines >= 800)
			{
				Plugin.Log.LogInfo((object)("[Audit] (tree truncated at " + 800 + " lines - faults below are still counted in full.)"));
			}
			Capabilities(root, list);
			if (list.Count == 0)
			{
				Plugin.Log.LogInfo((object)"[Audit] no overlaps, no overflow, no zero-sized boxes, and every control can be reached and clicked.");
			}
			else
			{
				Plugin.Log.LogWarning((object)("[Audit] " + list.Count + " fault(s):"));
				for (int i = 0; i < list.Count && i < 40; i++)
				{
					Plugin.Log.LogWarning((object)("[Audit]   " + list[i]));
				}
				if (list.Count > 40)
				{
					Plugin.Log.LogWarning((object)("[Audit]   ... and " + (list.Count - 40) + " more, most of them the same fault on another control."));
				}
			}
			Plugin.Log.LogInfo((object)("[Audit] ---- end " + tag + " ----"));
		}

		private static void Capabilities(GameObject root, List<string> faults)
		{
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: 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_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0318: 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_0335: Unknown result type (might be due to invalid IL or missing references)
			//IL_0343: Unknown result type (might be due to invalid IL or missing references)
			//IL_035d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0386: Unknown result type (might be due to invalid IL or missing references)
			//IL_038b: Unknown result type (might be due to invalid IL or missing references)
			//IL_038c: Unknown result type (might be due to invalid IL or missing references)
			//IL_039a: Expected O, but got Unknown
			//IL_03aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_03af: Unknown result type (might be due to invalid IL or missing references)
			Appearance(root, faults);
			Plugin.Log.LogInfo((object)"[Audit] -- what can actually be used --");
			ScrollRect[] componentsInChildren = root.GetComponentsInChildren<ScrollRect>(true);
			foreach (ScrollRect val in componentsInChildren)
			{
				if (!((Object)(object)val == (Object)null) && !((Object)(object)val.content == (Object)null) && !((Object)(object)val.viewport == (Object)null))
				{
					Rect rect = val.viewport.rect;
					float height = ((Rect)(ref rect)).height;
					rect = val.content.rect;
					float height2 = ((Rect)(ref rect)).height;
					float num = height2 - height;
					float verticalNormalizedPosition = val.verticalNormalizedPosition;
					Plugin.Log.LogInfo((object)("[Audit]   scroll " + Path(((Component)val).transform) + "  viewport " + height.ToString("0") + "  content " + height2.ToString("0") + ((num > 1f) ? ("  hidden " + num.ToString("0")) : "  fits") + "  parked at " + verticalNormalizedPosition.ToString("0.00") + " (1 = top)  bar " + (((Object)(object)val.verticalScrollbar == (Object)null) ? "MISSING" : (((Component)val.verticalScrollbar).gameObject.activeInHierarchy ? "shown" : "hidden")) + "  wheel " + (((Object)(object)((Component)val).GetComponent<NativeScroll>() != (Object)null) ? "ours" : "ScrollRect")));
					if (num > 1f && (Object)(object)val.verticalScrollbar == (Object)null && (Object)(object)((Component)val).GetComponent<NativeScroll>() == (Object)null)
					{
						faults.Add(Path(((Component)val).transform) + ": " + num.ToString("0") + "px hidden and neither a scrollbar nor a wheel handler to reach it with.");
					}
					if (num > 1f && verticalNormalizedPosition < 0.01f)
					{
						faults.Add(Path(((Component)val).transform) + ": opens at the BOTTOM with " + num.ToString("0") + "px above the view - everything in this column is off the top of the screen.");
					}
				}
			}
			EventSystem current = EventSystem.current;
			if ((Object)(object)current == (Object)null)
			{
				faults.Add("no EventSystem - nothing on the sheet can be clicked at all.");
				return;
			}
			int num2 = 0;
			int num3 = 0;
			int num4 = 0;
			int num5 = 0;
			int num6 = 0;
			List<RaycastResult> list = new List<RaycastResult>();
			Selectable[] componentsInChildren2 = root.GetComponentsInChildren<Selectable>(true);
			Vector2 val5 = default(Vector2);
			foreach (Selectable val2 in componentsInChildren2)
			{
				if ((Object)(object)val2 == (Object)null)
				{
					continue;
				}
				if (!((Component)val2).gameObject.activeInHierarchy || !val2.interactable)
				{
					num5++;
					continue;
				}
				Transform transform = ((Component)val2).transform;
				RectTransform val3 = (RectTransform)(object)((transform is RectTransform) ? transform : null);
				if ((Object)(object)val3 == (Object)null)
				{
					num5++;
					continue;
				}
				Rect val4 = ScreenRect(val3);
				((Vector2)(ref val5))..ctor(((Rect)(ref val4)).x + ((Rect)(ref val4)).width * 0.5f, ((Rect)(ref val4)).y + ((Rect)(ref val4)).height * 0.5f);
				if (val5.x < 0f || val5.x > (float)Screen.width || val5.y < 0f || val5.y > (float)Screen.height)
				{
					num3++;
				}
				else if (Clipped(val3, val5))
				{
					num3++;
				}
				else
				{
					if (num6++ >= 60)
					{
						continue;
					}
					list.Clear();
					current.RaycastAll(new PointerEventData(current)
					{
						position = val5
					}, list);
					object obj;
					if (list.Count <= 0)
					{
						obj = null;
					}
					else
					{
						RaycastResult val6 = list[0];
						obj = ((RaycastResult)(ref val6)).gameObject;
					}
					GameObject val7 = (GameObject)obj;
					if ((Object)(object)val7 != (Object)null && ((Object)(object)val7 == (Object)(object)((Component)val2).gameObject || val7.transform.IsChildOf(((Component)val2).transform)))
					{
						num2++;
						continue;
					}
					num4++;
					if (num4 <= 6)
					{
						faults.Add(Path(((Component)val2).transform) + ": a click at its centre lands on " + (((Object)(object)val7 == (Object)null) ? "nothing" : Quote(((Object)val7).name)) + " instead.");
					}
				}
			}
			Plugin.Log.LogInfo((object)("[Audit]   controls: " + num2 + " clickable, " + num4 + " blocked, " + num3 + " off-screen (scroll to reach), " + num5 + " inactive."));
			if (num3 > 0 && num2 == 0)
			{
				faults.Add("every control is off-screen - the sheet is built but none of it can be reached where it is parked.");
			}
		}

		private static void Appearance(GameObject root, List<string> faults)
		{
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: 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)
			//IL_0146: 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_017a: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dd: Unknown result type (might be due to invalid IL or missing references)
			string text = ((Plugin.Backdrop != null) ? (Plugin.Backdrop.Value ?? "") : "");
			Image component = root.GetComponent<Image>();
			string text2 = (((Object)(object)component != (Object)null && (Object)(object)((Graphic)component).material != (Object)null && (Object)(object)((Graphic)component).material != (Object)(object)Graphic.defaultGraphicMaterial) ? ((Object)((Graphic)component).material).name : null);
			Transform val = root.transform.Find("Tint");
			Image val2 = (((Object)(object)val != (Object)null) ? ((Component)val).GetComponent<Image>() : null);
			Plugin.Log.LogInfo((object)("[Audit] appearance: tint " + (((Object)(object)val2 != (Object)null) ? Say(((Graphic)val2).color) : "MISSING") + "  backdrop " + (string.IsNullOrWhiteSpace(text) ? "ours (no material)" : ("'" + text + "'")) + "  material " + (text2 ?? "none") + "  root " + (((Object)(object)component != (Object)null) ? Say(((Graphic)component).color) : "none")));
			if ((Object)(object)val2 == (Object)null)
			{
				faults.Add("the sheet has no Tint layer - whatever colour it is, it is not the one Theme decides.");
			}
			else if (!Near(((Graphic)val2).color, Theme.Glass))
			{
				faults.Add("the sheet's tint is " + Say(((Graphic)val2).color) + " but Theme.Glass is " + Say(Theme.Glass) + " - something is painting over the palette.");
			}
			if (string.IsNullOrWhiteSpace(text) && text2 != null)
			{
				faults.Add("the sheet borrowed '" + text2 + "' but Interface/Backdrop is empty - nothing should have been borrowed at all.");
			}
			if (text2 == null && (Object)(object)component != (Object)null && ((Graphic)component).color.a > 0.02f)
			{
				faults.Add("the sheet's base is " + Say(((Graphic)component).color) + " with no material - it should be fully transparent and let the Tint do the work.");
			}
			if (!string.IsNullOrWhiteSpace(text) && text2 == null)
			{
				Plugin.Log.LogInfo((object)("[Audit]   (backdrop '" + text + "' was asked for and is not in this scene - plain sheet, by design.)"));
			}
		}

		private static bool Near(Color a, Color b)
		{
			//IL_0000: 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_0019: 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_0032: 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_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			if (Mathf.Abs(a.r - b.r) < 0.02f && Mathf.Abs(a.g - b.g) < 0.02f && Mathf.Abs(a.b - b.b) < 0.02f)
			{
				return Mathf.Abs(a.a - b.a) < 0.02f;
			}
			return false;
		}

		private static string Say(Color c)
		{
			return "rgba(" + c.r.ToString("0.##") + "," + c.g.ToString("0.##") + "," + c.b.ToString("0.##") + "," + c.a.ToString("0.##") + ")";
		}

		private static string Canvasing(GameObject root)
		{
			//IL_0071: 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_0091: 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_00b5: 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)
			Canvas componentInParent = root.GetComponentInParent<Canvas>();
			if ((Object)(object)componentInParent == (Object)null)
			{
				return "  (no canvas!)";
			}
			string text = "  canvas scale " + componentInParent.scaleFactor.ToString("0.###") + " order " + componentInParent.sortingOrder;
			CanvasScaler component = ((Component)componentInParent).GetComponent<CanvasScaler>();
			if ((Object)(object)component != (Object)null)
			{
				text = text + "  scaler " + ((object)component.uiScaleMode/*cast due to .constrained prefix*/).ToString() + " ref " + component.referenceResolution.x.ToString("0") + "x" + component.referenceResolution.y.ToString("0") + " match " + component.matchWidthOrHeight.ToString("0.##");
			}
			return text;
		}

		private static void Walk(Transform t, int depth, List<string> faults)
		{
			//IL_0018: 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_015d: Unknown result type (might be due to invalid IL or missing references)
			if (depth > 8)
			{
				return;
			}
			RectTransform rt = (RectTransform)(object)((t is RectTransform) ? t : null);
			string text = new string(' ', depth * 2);
			Rect r = ScreenRect(rt);
			if (_lines++ < 800)
			{
				Plugin.Log.LogInfo((object)("[Audit]   " + text + ((Object)t).name + "  [" + ((Rect)(ref r)).x.ToString("0") + "," + ((Rect)(ref r)).y.ToString("0") + " " + ((Rect)(ref r)).width.ToString("0") + "x" + ((Rect)(ref r)).height.ToString("0") + "]  " + Layouting(t) + "  |  " + string.Join(", ", (from c in ((Component)t).GetComponents<Component>()
					where (Object)(object)c != (Object)null
					select ((object)c).GetType().Name).ToArray())));
			}
			Check(t, rt, r, faults);
			for (int num = 0; num < t.childCount; num++)
			{
				Walk(t.GetChild(num), depth + 1, faults);
			}
		}

		private static string Layouting(Transform t)
		{
			//IL_027e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0283: Unknown result type (might be due to invalid IL or missing references)
			//IL_0298: Unknown result type (might be due to invalid IL or missing references)
			//IL_029d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0469: Unknown result type (might be due to invalid IL or missing references)
			//IL_046e: Unknown result type (might be due to invalid IL or missing references)
			//IL_048a: Unknown result type (might be due to invalid IL or missing references)
			//IL_048f: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_04b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_030a: 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_032e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0333: Unknown result type (might be due to invalid IL or missing references)
			//IL_0352: Unknown result type (might be due to invalid IL or missing references)
			//IL_0357: Unknown result type (might be due to invalid IL or missing references)
			//IL_0376: Unknown result type (might be due to invalid IL or missing references)
			//IL_037b: Unknown result type (might be due to invalid IL or missing references)
			List<string> list = new List<string>();
			HorizontalOrVerticalLayoutGroup component = ((Component)t).GetComponent<HorizontalOrVerticalLayoutGroup>();
			if ((Object)(object)component != (Object)null)
			{
				list.Add(((component is VerticalLayoutGroup) ? "VLG" : "HLG") + " space " + component.spacing.ToString("0.#") + " pad " + ((LayoutGroup)component).padding.left + "/" + ((LayoutGroup)component).padding.right + "/" + ((LayoutGroup)component).padding.top + "/" + ((LayoutGroup)component).padding.bottom + " ctrl " + (component.childControlWidth ? "W" : "-") + (component.childControlHeight ? "H" : "-") + " expand " + (component.childForceExpandWidth ? "W" : "-") + (component.childForceExpandHeight ? "H" : "-"));
			}
			LayoutElement[] components = ((Component)t).GetComponents<LayoutElement>();
			foreach (LayoutElement val in components)
			{
				list.Add("LE min " + val.minWidth.ToString("0.#") + "/" + val.minHeight.ToString("0.#") + " pref " + val.preferredWidth.ToString("0.#") + "/" + val.preferredHeight.ToString("0.#") + " flex " + val.flexibleWidth.ToString("0.##") + "/" + val.flexibleHeight.ToString("0.##") + (val.ignoreLayout ? " IGNORED" : ""));
			}
			ContentSizeFitter component2 = ((Component)t).GetComponent<ContentSizeFitter>();
			if ((Object)(object)component2 != (Object)null)
			{
				list.Add("CSF h:" + ((object)component2.horizontalFit/*cast due to .constrained prefix*/).ToString() + " v:" + ((object)component2.verticalFit/*cast due to .constrained prefix*/).ToString());
			}
			Graphic component3 = ((Component)t).GetComponent<Graphic>();
			if ((Object)(object)component3 != (Object)null && !(component3 is TMP_Text))
			{
				bool flag = (Object)(object)component3.material != (Object)null && (Object)(object)component3.material != (Object)(object)Graphic.defaultGraphicMaterial;
				list.Add("rgba " + component3.color.r.ToString("0.##") + "," + component3.color.g.ToString("0.##") + "," + component3.color.b.ToString("0.##") + "," + component3.color.a.ToString("0.##") + (flag ? (" mat:" + ((Object)component3.material).name) : "") + (component3.raycastTarget ? "" : " noraycast"));
			}
			TMP_Text component4 = ((Component)t).GetComponent<TMP_Text>();
			if ((Object)(object)component4 != (Object)null)
			{
				list.Add("TMP font " + component4.fontSize.ToString("0.#") + (component4.enableAutoSizing ? (" auto " + component4.fontSizeMin.ToString("0.#") + "-" + component4.fontSizeMax.ToString("0.#")) : "") + " " + ((object)component4.alignment/*cast due to .constrained prefix*/).ToString() + " wrap:" + ((object)component4.textWrappingMode/*cast due to .constrained prefix*/).ToString() + " over:" + ((object)component4.overflowMode/*cast due to .constrained prefix*/).ToString() + " pref " + component4.preferredWidth.ToString("0") + "x" + component4.preferredHeight.ToString("0") + " " + Quote(component4.text));
			}
			if (list.Count != 0)
			{
				return string.Join("  ", list.ToArray());
			}
			return "-";
		}

		private static void Check(Transform t, RectTransform rt, Rect r, List<string> faults)
		{
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_0196: Unknown result type (might be due to invalid IL or missing references)
			//IL_019b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a5: 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_0216: Unknown result type (might be due to invalid IL or missing references)
			//IL_0218: Unknown result type (might be due to invalid IL or missing references)
			//IL_0224: Unknown result type (might be due to invalid IL or missing references)
			//IL_0226: Unknown result type (might be due to invalid IL or missing references)
			string text = Path(t);
			LayoutElement[] components = ((Component)t).GetComponents<LayoutElement>();
			if (components.Length > 1)
			{
				faults.Add(text + ": " + components.Length + " LayoutElements on one object - Unity takes the largest, so the value set in code is not necessarily the one in force.");
			}
			if ((Object)(object)rt != (Object)null && !Ignorable(t))
			{
				if (((Rect)(ref r)).width <= 0.5f || ((Rect)(ref r)).height <= 0.5f)
				{
					faults.Add(text + ": no size (" + ((Rect)(ref r)).width.ToString("0.#") + "x" + ((Rect)(ref r)).height.ToString("0.#") + ").");
				}
				Transform parent = t.parent;
				RectTransform val = (RectTransform)(object)((parent is RectTransform) ? parent : null);
				if ((Object)(object)val != (Object)null && HasGroup(t.parent))
				{
					string text2 = Escapes(r, ScreenRect(val));
					if (text2 != null)
					{
						faults.Add(text + ": hangs outside its parent " + text2 + " - this is what gets cut off.");
					}
				}
			}
			if ((Object)(object)((Component)t).GetComponent<Selectable>() != (Object)null)
			{
				return;
			}
			List<RectTransform> list = new List<RectTransform>();
			for (int i = 0; i < t.childCount; i++)
			{
				Transform child = t.GetChild(i);
				RectTransform val2 = (RectTransform)(object)((child is RectTransform) ? child : null);
				if (!((Object)(object)val2 == (Object)null) && ((Component)val2).gameObject.activeInHierarchy && !Ignorable(((Component)val2).transform))
				{
					list.Add(val2);
				}
			}
			for (int j = 0; j < list.Count; j++)
			{
				for (int k = j + 1; k < list.Count; k++)
				{
					Rect val3 = ScreenRect(list[j]);
					Rect val4 = ScreenRect(list[k]);
					float num = Mathf.Min(((Rect)(ref val3)).xMax, ((Rect)(ref val4)).xMax) - Mathf.Max(((Rect)(ref val3)).xMin, ((Rect)(ref val4)).xMin);
					float num2 = Mathf.Min(((Rect)(ref val3)).yMax, ((Rect)(ref val4)).yMax) - Mathf.Max(((Rect)(ref val3)).yMin, ((Rect)(ref val4)).yMin);
					if (!(num <= 1f) && !(num2 <= 1f) && !Inside(val3, val4) && !Inside(val4, val3))
					{
						faults.Add(text + ": " + Quote(((Object)list[j]).name) + " and " + Quote(((Object)list[k]).name) + " overlap by " + num.ToString("0") + "x" + num2.ToString("0") + "px.");
					}
				}
			}
		}

		private static bool Inside(Rect inner, Rect outer)
		{
			if (((Rect)(ref inner)).xMin >= ((Rect)(ref outer)).xMin - 1f && ((Rect)(ref inner)).xMax <= ((Rect)(ref outer)).xMax + 1f && ((Rect)(ref inner)).yMin >= ((Rect)(ref outer)).yMin - 1f)
			{
				return ((Rect)(ref inner)).yMax <= ((Rect)(ref outer)).yMax + 1f;
			}
			return false;
		}

		private static string Escapes(Rect r, Rect p)
		{
			List<string> list = new List<string>();
			if (((Rect)(ref r)).xMin < ((Rect)(ref p)).xMin - 1f)
			{
				list.Add("left by " + (((Rect)(ref p)).xMin - ((Rect)(ref r)).xMin).ToString("0"));
			}
			if (((Rect)(ref r)).xMax > ((Rect)(ref p)).xMax + 1f)
			{
				list.Add("right by " + (((Rect)(ref r)).xMax - ((Rect)(ref p)).xMax).ToString("0"));
			}
			if (((Rect)(ref r)).yMin < ((Rect)(ref p)).yMin - 1f)
			{
				list.Add("bottom by " + (((Rect)(ref p)).yMin - ((Rect)(ref r)).yMin).ToString("0"));
			}
			if (((Rect)(ref r)).yMax > ((Rect)(ref p)).yMax + 1f)
			{
				list.Add("top by " + (((Rect)(ref r)).yMax - ((Rect)(ref p)).yMax).ToString("0"));
			}
			if (list.Count != 0)
			{
				return "(" + string.Join(", ", list.ToArray()) + "px)";
			}
			return null;
		}

		private static bool Ignorable(Transform t)
		{
			if ((Object)(object)t == (Object)null)
			{
				return true;
			}
			if ((Object)(object)((Component)t).GetComponent<TMP_SubMeshUI>() != (Object)null)
			{
				return true;
			}
			if (((Object)t).name.StartsWith("TMP SubMesh"))
			{
				return true;
			}
			LayoutElement component = ((Component)t).GetComponent<LayoutElement>();
			if ((Object)(object)component != (Object)null)
			{
				return component.ignoreLayout;
			}
			return false;
		}

		private static bool Clipped(RectTransform rt, Vector2 point)
		{
			//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_0033: Unknown result type (might be due to invalid IL or missing references)
			Transform parent = ((Transform)rt).parent;
			RectTransform val = (RectTransform)(object)((parent is RectTransform) ? parent : null);
			while ((Object)(object)val != (Object)null)
			{
				if (!((Object)(object)((Component)val).GetComponent<RectMask2D>() == (Object)null) || !((Object)(object)((Component)val).GetComponent<Mask>() == (Object)null))
				{
					Rect val2 = ScreenRect(val);
					if (!((Rect)(ref val2)).Contains(point))
					{
						return true;
					}
				}
				Transform parent2 = ((Transform)val).parent;
				val = (RectTransform)(object)((parent2 is RectTransform) ? parent2 : null);
			}
			return false;
		}

		private static bool HasGroup(Transform t)
		{
			if ((Object)(object)t != (Object)null)
			{
				return (Object)(object)((Component)t).GetComponent<LayoutGroup>() != (Object)null;
			}
			return false;
		}

		private static Rect ScreenRect(RectTransform rt)
		{
			//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_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_0046: 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_0052: 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_005f: 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_006c: 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)
			if ((Object)(object)rt == (Object)null)
			{
				return new Rect(0f, 0f, 0f, 0f);
			}
			rt.GetWorldCorners(_corners);
			Vector3 val = _corners[0];
			Vector3 val2 = _corners[2];
			return new Rect(val.x, val.y, val2.x - val.x, val2.y - val.y);
		}

		private static string Path(Transform t)
		{
			string text = ((Object)t).name;
			Transform parent = t.parent;
			for (int i = 0; i < 2; i++)
			{
				if (!((Object)(object)parent != (Object)null))
				{
					break;
				}
				text = ((Object)parent).name + "/" + text;
				parent = parent.parent;
			}
			return text;
		}

		private static string Quote(string s)
		{
			if (string.IsNullOrEmpty(s))
			{
				return "\"\"";
			}
			s = s.Replace("\r", "").Replace("\n", "\\n");
			if (s.Length > 28)
			{
				s = s.Substring(0, 28) + "...";
			}
			return "\"" + s + "\"";
		}
	}
	internal static class NativeConsole
	{
		private enum Tab
		{
			Warden,
			Settings,
			Tweaks
		}

		private static GameObject _root;

		private static Transform _whoCol;

		private static Transform _wardenCol;

		private static Transform _toolCol;

		private static Transform _wardenInner;

		private static Transform _toolInner;

		private static Transform _guardCol;

		private static Transform _whoInner;

		private static Transform _guardInner;

		private static Transform _setInner;

		private static Transform _railRow;

		private static ScrollRect _guardScroll;

		private static TMP_InputField _search;

		private static string _spawnQuery = "";

		private static bool _refocus;

		private static int _spawnPage;

		private static bool _fresh = true;

		private static bool _showRules;

		private static float _searchSettles;

		private static Tab _tab = Tab.Warden;

		private static Tab _builtTab = Tab.Tweaks;

		private static Transform _tabRow;

		private static Transform _body;

		private static readonly List<ScrollRect> _scrolls = new List<ScrollRect>();

		private static readonly List<float> _keep = new List<float>();

		private static readonly Transform[] _tools = (Transform[])(object)new Transform[3];

		private static readonly float[] _fill = new float[3];

		private static int _at;

		private static ScrollRect _whoScroll;

		private static ScrollRect _wardenScroll;

		private static ScrollRect _toolScroll;

		private static Transform _levelRow;

		private static TMP_Text _title;

		private static TMP_Text _dossier;

		private static TMP_Text _toast;

		private static float _toastUntil;

		private static float _nextRefresh;

		private static ulong _selected;

		private const int PageSize = 40;

		private const int SearchMax = 25;

		private static bool _dirty;

		private static ulong _builtFor = ulong.MaxValue;

		private static int _builtPlayers = -1;

		private static string _armed;

		private static float _armedUntil;

		public static bool IsOpen { get; private set; }

		public static bool Open()
		{
			if (!NativeUI.Prepare())
			{
				return false;
			}
			if (IsOpen)
			{
				return true;
			}
			try
			{
				Build();
				IsOpen = true;
				NativeAudit.Request(_root, "console layout");
				return true;
			}
			catch (Exception ex)
			{
				Plugin.Log.LogError((object)("[NativeConsole] could not build, falling back to the old one: " + ex));
				Close();
				return false;
			}
		}

		public static void Close()
		{
			IsOpen = false;
			if ((Object)(object)_root != (Object)null)
			{
				Object.Destroy((Object)(object)_root);
			}
			_root = null;
			_whoCol = (_wardenCol = (_toolCol = (_levelRow = (_railRow = null))));
			_wardenInner = (_toolInner = null);
			_tabRow = (_body = null);
			_scrolls.Clear();
			_keep.Clear();
			for (int i = 0; i < _tools.Length; i++)
			{
				_tools[i] = null;
				_fill[i] = 0f;
			}
			_search = null;
			_refocus = false;
			_fresh = true;
			_searchSettles = 0f;
			_whoScroll = (_wardenScroll = (_toolScroll = null));
			_title = (_dossier = (_toast = null));
			NativeUI.OnHover = null;
			NativeUI.ForgetLabels();
			_builtFor = ulong.MaxValue;
			_builtPlayers = -1;
			_dirty = false;
		}

		public static void Toast(string msg)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)_toast == (Object)null))
			{
				NativeUI.Say(_toast, msg ?? "");
				((Graphic)_toast).color = Theme.Ink;
				_toastUntil = Time.realtimeSinceStartup + 6f;
			}
		}

		private static void Hint(string text)
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)_toast == (Object)null) && !string.IsNullOrEmpty(text) && !(_toastUntil > Time.realtimeSinceStartup))
			{
				NativeUI.Say(_toast, text);
				((Graphic)_toast).color = Theme.Muted;
			}
		}

		private static void Build()
		{
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Expected O, but got Unknown
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0149: Unknown result type (might be due to invalid IL or missing references)
			//IL_0176: Unknown result type (might be due to invalid IL or missing references)
			_root = NativeUI.Sheet("EndersGambit", 0.9f, 0.88f);
			VerticalLayoutGroup obj = _root.AddComponent<VerticalLayoutGroup>();
			((LayoutGroup)obj).padding = new RectOffset(22, 22, 18, 16);
			((HorizontalOrVerticalLayoutGroup)obj).spacing = 6f;
			((HorizontalOrVerticalLayoutGroup)obj).childControlHeight = true;
			((HorizontalOrVerticalLayoutGroup)obj).childControlWidth = true;
			((HorizontalOrVerticalLayoutGroup)obj).childForceExpandHeight = false;
			((HorizontalOrVerticalLayoutGroup)obj).childForceExpandWidth = true;
			_title = NativeUI.Label(_root.transform, "Fish Warden", Vector2.zero);
			Fix(_title, 36f, (TextAlignmentOptions)513);
			_railRow = Strip(_root.transform, "Rail", 0f).transform;
			_levelRow = Strip(_root.transform, "Levels", 34f).transform;
			_tabRow = Strip(_root.transform, "Tabs", 34f).transform;
			GameObject obj2 = Strip(_root.transform, "Body", 0f);
			LayoutElement component = obj2.GetComponent<LayoutElement>();
			component.preferredHeight = 0f;
			component.flexibleHeight = 1f;
			_body = obj2.transform;
			_toast = NativeUI.Label(_root.transform, "Point at anything to see what it does.", Vector2.zero);
			Fix(_toast, 40f, (TextAlignmentOptions)513);
			((Graphic)_toast).color = Theme.Muted;
			NativeUI.OnHover = Hint;
			BuildLevels();
			BuildTabs();
			Refresh(rebuild: true);
		}

		private static void BuildTabs()
		{
			//IL_0010: 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)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			Clear(_tabRow);
			Page("WARDEN", Tab.Warden, Theme.EdgeWarden, "Everyone in the lobby and what you can do about them. This is the tab for when something is happening.");
			Page("SETTINGS", Tab.Settings, Theme.EdgeWarden, "How the guard behaves - what a finding costs, which checks run, how big the lobby is. Set once, then forgotten.");
			Page("ENDER'S TWEAKS", Tab.Tweaks, Theme.EdgeTweaks, "Your own kit. None of this touches anyone else's game.");
		}

		private static void Page(string label, Tab which, Color edge, string hint)
		{
			//IL_004b: 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_0088: 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)
			bool flag = _tab == which;
			GameObject val = NativeUI.Button(_tabRow, (flag ? "✓  " : "     ") + label, delegate
			{
				if (_tab != which)
				{
					_tab = which;
					Mark();
				}
			}, new Vector2(0f, 40f), Vector2.zero, hint);
			(val.GetComponent<LayoutElement>() ?? val.AddComponent<LayoutElement>()).flexibleWidth = 1f;
			NativeUI.Mark(val, flag);
			NativeUI.Edge(val, flag ? edge : Theme.EdgeIdle);
		}

		private static GameObject Strip(Transform parent, string name, float height)
		{
			//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_0040: 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_008e: Expected O, but got Unknown
			GameObject val = new GameObject(name, new Type[3]
			{
				typeof(RectTransform),
				typeof(HorizontalLayoutGroup),
				typeof(LayoutElement)
			});
			val.transform.SetParent(parent, false);
			HorizontalLayoutGroup component = val.GetComponent<HorizontalLayoutGroup>();
			((HorizontalOrVerticalLayoutGroup)component).spacing = 14f;
			((HorizontalOrVerticalLayoutGroup)component).childControlWidth = true;
			((HorizontalOrVerticalLayoutGroup)component).childControlHeight = true;
			((HorizontalOrVerticalLayoutGroup)component).childForceExpandHeight = true;
			((HorizontalOrVerticalLayoutGroup)component).childForceExpandWidth = false;
			LayoutElement component2 = val.GetComponent<LayoutElement>();
			if (height > 0f)
			{
				component2.preferredHeight = height;
				component2.flexibleHeight = 0f;
			}
			return val;
		}

		private static Transform Column(Transform parent, string title, float weight, out ScrollRect scroll)
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Expected O, but got Unknown
			//IL_00a5: 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_00bf: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject(title, new Type[3]
			{
				typeof(RectTransform),
				typeof(VerticalLayoutGroup),
				typeof(LayoutElement)
			});
			val.transform.SetParent(parent, false);
			VerticalLayoutGroup component = val.GetComponent<VerticalLayoutGroup>();
			((HorizontalOrVerticalLayoutGroup)component).spacing = 4f;
			((HorizontalOrVerticalLayoutGroup)component).childControlWidth = true;
			((HorizontalOrVerticalLayoutGroup)component).childControlHeight = true;
			((HorizontalOrVerticalLayoutGroup)component).childForceExpandHeight = false;
			((HorizontalOrVerticalLayoutGroup)component).childForceExpandWidth = true;
			LayoutElement component2 = val.GetComponent<LayoutElement>();
			component2.flexibleWidth = weight;
			component2.preferredWidth = 0f;
			if (!string.IsNullOrEmpty(title))
			{
				NativeUI.Header(val.transform, title);
				TMP_Text val2 = NativeUI.Label(val.transform, Blurb(title), Vector2.zero);
				if ((Object)(object)val2 != (Object)null)
				{
					((Graphic)val2).color = Theme.Faint;
					Fix(val2, 34f, (TextAlignmentOptions)257);
				}
			}
			if (title == "ON THIS PERSON")
			{
				_dossier = NativeUI.Label(val.transform, "", Vector2.zero);
				Fix(_dossier, 116f, (TextAlignmentOptions)257);
			}
			Transform val3 = NativeUI.Scroll(val.transform, 0f);
			scroll = ((Component)val3.parent).GetComponent<ScrollRect>();
			_scrolls.Add(scroll);
			return val3;
		}

		private static string Blurb(string title)
		{
			return title switch
			{
				"WHO IS HERE" => "Everyone in the lobby, most-caught first. Click somebody to work on them.", 
				"ON THIS PERSON" => "What they have done, and what you can do about it.", 
				"THE GUARD" => "How it behaves, what it has seen, and the lobby as a whole.", 
				"ENDER'S TWEAKS" => "Your own kit. None of this touches anyone else's game.", 
				_ => "Settings for how the guard behaves.", 
			};
		}

		private static void BuildLevels()
		{
			//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_00c5: 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)
			Clear(_levelRow);
			foreach (Level value in Enum.GetValues(typeof(Level)))
			{
				Level mine = value;
				bool flag = Policy.Matches(value);
				GameObject val = NativeUI.Button(_levelRow, (flag ? "✓  " : "     ") + Policy.Name(value).ToUpperInvariant(), delegate
				{
					Plugin.SetLevel(mine);
					Mark();
				}, new Vector2(0f, 40f), Vector2.zero, Policy.Explain(value));
				(val.GetComponent<LayoutElement>() ?? val.AddComponent<LayoutElement>()).flexibleWidth = 1f;
				NativeUI.Mark(val, flag);
				NativeUI.Edge(val, flag ? Theme.EdgeLive : Theme.EdgeIdle);
			}
		}

		private static void Mark()
		{
			_dirty = true;
		}

		public static void Tick()
		{
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			if (IsOpen && !((Object)(object)_root == (Object)null))
			{
				NativeAudit.Tick();
				if (_searchSettles > 0f && Time.realtimeSinceStartup >= _searchSettles)
				{
					_searchSettles = 0f;
					_refocus = true;
					Mark();
				}
				if ((Object)(object)_toast != (Object)null && _toastUntil > 0f && Time.realtimeSinceStartup > _toastUntil)
				{
					NativeUI.Say(_toast, "Point at anything to see what it does.");
					((Graphic)_toast).color = Theme.Muted;
					_toastUntil = 0f;
				}
				NativeUI.HoldLabels();
				int count = Others().Count;
				if (_dirty || _selected != _builtFor || count != _builtPlayers)
				{
					_dirty = false;
					Refresh(rebuild: true);
				}
				else if (!(Time.realtimeSinceStartup < _nextRefresh))
				{
					_nextRefresh = Time.realtimeSinceStartup + 1f;
					Refresh(rebuild: false);
				}
			}
		}

		private static void Refresh(bool rebuild)
		{
			List<Player> list = Others();
			if (rebuild)
			{
				_builtFor = _selected;
				_builtPlayers = list.Count;
				bool num = !_fresh && _builtTab == _tab;
				_keep.Clear();
				if (num)
				{
					foreach (ScrollRect scroll in _scrolls)
					{
						_keep.Add(Where(scroll));
					}
				}
				_fresh = false;
				_builtTab = _tab;
				NativeUI.ForgetLabels();
				Clear(_body);
				_scrolls.Clear();
				_whoCol = (_wardenCol = (_toolCol = null));
				_wardenInner = (_toolInner = null);
				if (_tab == Tab.Warden)
				{
					BuildWardenTab(list);
				}
				else if (_tab == Tab.Settings)
				{
					BuildSettingsTab();
				}
				else
				{
					BuildTweaksTab();
				}
				BuildLevels();
				BuildTabs();
				BuildRail();
				Canvas.ForceUpdateCanvases();
				for (int i = 0; i < _scrolls.Count && i < _keep.Count; i++)
				{
					Restore(_scrolls[i], _keep[i]);
				}
				if (_refocus && (Object)(object)_search != (Object)null)
				{
					_refocus = false;
					_search.ActivateInputField();
					_search.caretPosition = _search.text.Length;
				}
			}
			UpdateDossier();
			if ((Object)(object)_title != (Object)null)
			{
				string text = Actions.Status();
				NativeUI.Say(_title, "Fish Warden  build " + Plugin.BuiltAt() + "   -   " + Policy.CurrentName() + (string.IsNullOrEmpty(text) ? "" : ("   -   " + text)));
			}
		}

		private static GameObject Urgent(Transform parent, string label, string hint, Func<string> run, bool loud)
		{
			//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_0073: 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_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: 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)
			GameObject val = NativeUI.Button(parent, label, delegate
			{
				string text = run();
				Plugin.Log.LogInfo((object)("[Console] rail \"" + label + "\" -> " + (text ?? "(no message)")));
				Toast(text);
				Mark();
			}, new Vector2(0f, 40f), Vector2.zero, hint);
			(val.GetComponent<LayoutElement>() ?? val.AddComponent<LayoutElement>()).flexibleWidth = (loud ? 1.6f : 1f);
			NativeUI.Back(val, loud ? Theme.RowOn : Theme.Row);
			NativeUI.Edge(val, loud ? Theme.EdgeGrave : Theme.EdgeWarden);
			NativeUI.Paint(val, Theme.Ink);
			return val;
		}

		private static void BuildRail()
		{
			Clear(_railRow);
			LayoutElement component = ((Component)_railRow).GetComponent<LayoutElement>();
			int num = 0;
			foreach (Cases.Case item in Cases.Open.ToList())
			{
				int id = item.Id;
				string name = item.Name;
				Urgent(_railRow, "REMOVE " + name.ToUpperInvariant() + "  (" + item.Strikes + ")", "What the guard caught: " + ((item.Rules.Count == 0) ? "nothing named" : string.Join(", ", item.Rules.ToArray())) + (item.Proven ? ". Proven, not guessed." : ". Suspicious rather than proven."), () => Cases.Accept(id), loud: true);
				Urgent(_railRow, "let " + name + " off", "Clears their strikes and undoes the punishment, and marks the rule as having produced a false alarm so a noisy one can be spotted.", () => Cases.Dismiss(id), loud: false);
				num += 2;
				if (num >= 6)
				{
					break;
				}
			}
			if (Safety.Tripped)
			{
				Urgent(_railRow, "GUARD STOOD DOWN  -  put it back", "Too many different people were flagged at once, so the guard decided the rules were wrong rather than the lobby and stopped enforcing. Nothing is being blocked until you re-arm it.", delegate
				{
					Safety.Rearm();
					return "Re-armed.";
				}, loud: true);
				num++;
			}
			int disabledCount = Rules.DisabledCount;
			if (disabledCount > 0 && num < 8)
			{
				Urgent(_railRow, disabledCount + " check(s) switched off", "Either you switched them off, or one fired so often the guard decided it was broken. Opens SETTINGS, where they can go back on.", delegate
				{
					_tab = Tab.Settings;
					Mark();
					return "Every check is in SETTINGS.";
				}, loud: false);
				num++;
			}
			component.preferredHeight = ((num == 0) ? 0f : 40f);
			component.flexibleHeight = 0f;
			((Component)_railRow).gameObject.SetActive(num > 0);
		}

		private static void BuildWardenTab(List<Player> players)
		{
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			_whoCol = Column(_body, "WHO IS HERE", 0.8f, out _whoScroll);
			_wardenCol = Column(_body, "ON THIS PERSON", 1.15f, out _wardenScroll);
			_guardCol = Column(_body, "THE GUARD", 1.05f, out _guardScroll);
			_whoInner = NativeUI.Group(_whoCol, Theme.EdgeWarden);
			_wardenInner = NativeUI.Group(_wardenCol, Theme.EdgeWarden);
			_guardInner = NativeUI.Group(_guardCol, Theme.EdgeWarden);
			BuildDecide();
			BuildWho(players);
			BuildWarden();
			BuildGuard();
		}

		private static void BuildDecide()
		{
		}

		private static void BuildTweaksTab()
		{
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			string text = "ENDER'S TWEAKS";
			for (int i = 0; i < _tools.Length; i++)
			{
				ScrollRect scroll;
				Transform parent = Column(_body, (i == 0) ? text : "", 1f, out scroll);
				if (i == 0)
				{
					_toolScroll = scroll;
				}
				_tools[i] = NativeUI.Group(parent, Theme.EdgeTweaks);
				_fill[i] = 0f;
			}
			_fill[0] = 60f;
			_at = 0;
			_toolCol = _tools[0];
			_toolInner = _tools[0];
			BuildTools();
		}

		private static void Section(string title)
		{
			if (_tab == Tab.Warden)
			{
				NativeUI.Header(_toolInner ?? _guardInner, title);
				return;
			}
			int num = 0;
			for (int i = 1; i < _tools.Length; i++)
			{
				if (_fill[i] < _fill[num])
				{
					num = i;
				}
			}
			_at = num;
			_toolInner = _tools[num];
			_setInner = _tools[num];
			_fill[num] += 30f;
			NativeUI.Header(_tools[num], title);
		}

		private static void Grew(Transform parent, float height)
		{
			if (_tab == Tab.Warden)
			{
				return;
			}
			for (int i = 0; i < _tools.Length; i++)
			{
				if ((Object)(object)_tools[i] == (Object)(object)parent)
				{
					_fill[i] += height;
					break;
				}
			}
		}

		private static void BuildWho(List<Player> players)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_021d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0222: Unknown result type (might be due to invalid IL or missing references)
			//IL_0257: Unknown result type (might be due to invalid IL or missing references)
			if (players.Count == 0)
			{
				NativeUI.Label(_whoInner, "nobody else in the lobby", Vector2.zero);
				return;
			}
			Dictionary<ulong, int> dictionary = new Dictionary<ulong, int>();
			foreach (Player player in players)
			{
				try
				{
					dictionary[player.SteamID] = ((!dictionary.TryGetValue(player.SteamID, out var value)) ? 1 : (value + 1));
				}
				catch
				{
				}
			}
			Dictionary<ulong, int> tally = Logbook.Tally();
			HashSet<ulong> hashSet = new HashSet<ulong>();
			foreach (Player item in players.OrderByDescending((Player x) => Strikes(tally, x)))
			{
				ulong steamID;
				try
				{
					steamID = item.SteamID;
				}
				catch
				{
					continue;
				}
				if (hashSet.Add(steamID))
				{
					int value2;
					int num = (tally.TryGetValue(steamID, out value2) ? value2 : 0);
					int value3;
					int num2 = ((!dictionary.TryGetValue(steamID, out value3)) ? 1 : value3);
					string label = item.SteamName + ((num2 > 1) ? ("  x" + num2) : "") + ((num > 0) ? ("   " + num) : "") + (Troll.Is(steamID) ? "  troll" : "") + (Actions.IsMuted(steamID) ? "  muted" : "") + (Actions.IsFrozen(steamID) ? "  frozen" : "");
					ulong target = steamID;
					string hint = ((num == 0) ? (item.SteamName + " has not been caught doing anything. Click to select them anyway.") : (item.SteamName + " has " + num + " strikes. Click to see what they did and what you can do about it."));
					GameObject go = NativeUI.Button(_whoInner, label, delegate
					{
						_selected = target;
						Mark();
					}, new Vector2(0f, 40f), Vector2.zero, hint);
					NativeUI.Mark(go, steamID == _selected);
					if (steamID != _selected)
					{
						NativeUI.Paint(go, Theme.ForStrikes(num, Plugin.KickThreshold.Value));
					}
				}
			}
		}

		private static int Strikes(Dictionary<ulong, int> tally, Player p)
		{
			try
			{
				int value;
				return tally.TryGetValue(p.SteamID, out value) ? value : 0;
			}
			catch
			{
				return 0;
			}
		}

		private static void BuildWarden()
		{
			Player p = Selected();
			if (!((Object)(object)p != (Object)null))
			{
				return;
			}
			NativeUI.Header(_wardenInner, "ON " + p.SteamName.ToUpperInvariant());
			Charges(p);
			Act(_wardenInner, Troll.Is(_selected) ? "Stop trolling them" : "Troll mode", "Every rule they break gets its own reply in chat. They are not stopped, they are mocked.", () => Troll.Toggle(p), Troll.Is(_selected));
			Act(_wardenInner, Actions.IsFrozen(_selected) ? "Let them move" : "Freeze", "Teleports them back to one spot several times a second. They can press anything they like and end up where they started.", () => Actions.ToggleFreeze(p), Actions.IsFrozen(_selected));
			Act(_wardenInner, Actions.IsMuted(_selected) ? "Let them talk" : "Mute", "Drops their chat and their voice for the WHOLE lobby, not just for you. Voice is relayed through you, so nobody hears them.", () => Actions.ToggleMute(p), Actions.IsMuted(_selected));
			if (Actions.IsMuted(_selected))
			{
				Act(_wardenInner, "Muted for: " + MuteLines.Name(Actions.ReasonFor(_selected)), "Why they were muted. This picks which lines the lobby sees when they try to talk - swearing, racism, politics and so on.", () => Actions.CycleReason(p));
			}
			Act(_wardenInner, "Take their things", "Drops everything they are carrying on the floor where they stand.", () => Actions.Strip(p));
			Act(_wardenInner, "Remove their duplicates", "Despawns their spare bodies but leaves the one they are playing.", () => Actions.Purge(p));
			Act(_wardenInner, "Blow up when they attack", "Next time they shoot or punch, it goes off in their hands.", () => Extras.Blowback(p), Extras.HasBlowback(_selected));
			Act(_wardenInner, "Worthless catches", "Everything they reel in sells for nothing.", () => Extras.Skunk(p), Extras.IsSkunked(_selected));
			Act(_wardenInner, Extras.IsButterfingers(_selected) ? "Let them hold things" : "Butterfingers", "They drop whatever they pick up, over and over. Useless to a cheat and very funny to watch.", () => Extras.Butterfingers(p), Extras.IsButterfingers(_selected));
			Act(_wardenInner, Extras.InCooler(_selected) ? "Let them up" : "Keep knocking them down", "Puts them on the floor again every time they stand up.", () => (!Extras.InCooler(_selected)) ? Extras.Cool(p) : Extras.Uncool(p), Extras.InCooler(_selected));
			Act(_wardenInner, "Out to sea", "Puts them a long way out in the water. They have to swim back.", () => Extras.Locker(p));
			Act(_wardenInner, "Smite" + Plugin.KeyLabel("Smite"), "A bolt from nowhere. Knocks them down hard, from here rather than by looking at them.", () => Smite.Strike(p));
			if (Rollback.HasDamage(_selected))
			{
				Act(_wardenInner, "Undo their damage", "Puts back what they broke, spawned or handed out while they were cheating.", () => Rollback.Gut(_selected));
			}
			Grave(_wardenInner, "REMOVE FROM LOBBY", "Remove " + p.SteamName + "?", "Kicks them now. If bans are on they cannot come back.", delegate
			{
				int value;
				int strikes = (Logbook.Tally().TryGetValue(_selected, out value) ? value : 0);
				string steamName = p.SteamName;
				Guard.RemoveNow(((NetworkBehaviour)p).Owner, strikes, "removed by hand");
				_selected = 0uL;
				return steamName + " removed.";
			});
			Act(_wardenInner, Crew.Has(_selected) ? "Revoke their fishing license" : "Issue a fishing license", "A license is the standing you have: no rule is run against them at all, so they can use whatever they like without being flagged, blocked, punished or removed, and they still get in during lockdown. The lobby is told when it is given and when it is taken back - a silent exemption looks exactly like a broken guard. It does not survive a restart.", () => Crew.Toggle(p), Crew.Has(_selected));
			Act(_wardenInner, "Pardon", "Wipes their strikes and undoes every punishment. Use this when the guard was wrong.", delegate
			{
				Logbook.Pardon(_selected);
				Rollback.Clear(_selected);
				Safety.Forget(_selected);
				Extras.Release(_selected);
				return p.SteamName + " pardoned.";
			});
		}

		private static void BuildGuard()
		{
			NativeUI.Header(_guardInner, "HOW IT BEHAVES");
			Act(_guardInner, "Remove on " + Plugin.KickThreshold.Value + " strikes: " + (Plugin.AutoKick.Value ? "yes" : "ask me first"), "Whether the guard kicks on its own once somebody hits the strike limit, or waits and asks you first.", delegate
			{
				Plugin.AutoKick.Value = !Plugin.AutoKick.Value;
				return (!Plugin.AutoKick.Value) ? "You will be asked before anyone is removed." : "Removals happen on their own.";
			}, Plugin.AutoKick.Value);
			Act(_guardInner, "Announce findings: " + (Plugin.AnnounceFindings.Value ? "yes" : "quietly"), "Whether the lobby is told in chat when somebody is caught, or whether it only goes to your log.", delegate
			{
				Plugin.AnnounceFindings.Value = !Plugin.AnnounceFindings.Value;
				return (!Plugin.AnnounceFindings.Value) ? "Findings stay in the log." : "Findings are announced in chat.";
			}, Plugin.AnnounceFindings.Value);
			Act(_guardInner, "Auto troll: " + AutoTroll.Describe(AutoTroll.Mode), "When troll mode should arm itself without you clicking: never, the moment anything proven lands, after enough strikes, or only for rules you pick.", delegate
			{
				AutoTroll.Trigger trigger = ((AutoTroll.Mode != AutoTroll.Trigger.ChosenRules) ? (AutoTroll.Mode + 1) : AutoTroll.Trigger.Off);
				AutoTroll.SetMode(trigger);
				return "Troll mode arms itself: " + AutoTroll.Describe(trigger);
			}, AutoTroll.Mode != AutoTroll.Trigger.Off);
			if (AutoTroll.Mode == AutoTroll.Trigger.AfterStrikes)
			{
				Dial(_guardInner, "Arm troll mode after", Plugin.AutoTrollStrikes.Value, 1f, 40f, delegate(float x)
				{
					Plugin.AutoTrollStrikes.Value = Mathf.RoundToInt(x);
				}, "0", whole: true);
				Note(_guardInner, "strikes on one person, before troll mode arms itself.");
			}
			else if (AutoTroll.Mode == AutoTroll.Trigger.ChosenRules)
			{
				List<string> list = AutoTroll.Chosen.ToList();
				Note(_guardInner, (list.Count == 0) ? "No rule arms it yet - pick at least one, or nothing will ever fire." : (list.Count + " rule(s) arm it on their own."));
				Transform[] array = Tiles(_guardInner, 2);
				List<string> list2 = Rules.Known.ToList();
				for (int num = 0; num < list2.Count; num++)
				{
					string name = list2[num];
					bool flag = AutoTroll.Arms(name);
					Act(array[num % array.Length], name.Replace("-", " "), flag ? "Catching this arms troll mode on its own. Click to stop that." : "Click to make this one arm troll mode by itself.", () => AutoTroll.ToggleRule(name), flag);
				}
			}
			Act(_guardInner, "Undo damage on removal: " + (Plugin.GutOnRemoval.Value ? "yes" : "no"), "Whether what somebody spawned, broke or handed out is put back when they are kicked.", delegate
			{
				Plugin.GutOnRemoval.Value = !Plugin.GutOnRemoval.Value;
				return (!Plugin.GutOnRemoval.Value) ? "Their damage stays when they go." : "What they broke is put back when they go.";
			}, Plugin.GutOnRemoval.Value);
			Dial(_guardInner, "Strikes before removal", Plugin.KickThreshold.Value, 1f, 20f, delegate(float x)
			{
				Plugin.KickThreshold.Value = Mathf.RoundToInt(x);
			}, "0", whole: true);
			NativeUI.Header(_guardInner, "THE WHOLE LOBBY");
			Act(_guardInner, Actions.Lockdown ? "End lockdown" : "Lock the lobby", Actions.Lockdown ? "Opens the lobby back up to anyone." : "Nobody new gets in except people you have trusted. For when a lobby is being raided.", () => Actions.ToggleLockdown(), Actions.Lockdown);
			Grave(_guardInner, "Undo what everyone did", "Undo everything, for everyone?", "Takes back everything the guard recorded anyone spawning, inflating or killing this session - not just the person you have selected. Nothing this console spawned is touched; that is the row above.", () => Rollback.GutAll());
			Grave(_guardInner, "Put the world back", "Rewrite the whole session?", "The heavier version: every recorded spawn removed, every inflated item returned to its real worth, and everyone they killed put back on their feet. For after a raid rather than after one person.", () => Rollback.RestoreWorld());
			Act(_guardInner, HostTools.FriendlyFire ? "Friendly fire: ON" : "Friendly fire: OFF", HostTools.FriendlyFire ? "Players can hurt each other. Punches between people do damage." : "Players CANNOT hurt each other - punching somebody does nothing at all. This is the game's own lobby setting, not the guard blocking anything.", () => HostTools.ToggleFriendlyFire(), HostTools.FriendlyFire);
			Act(_guardInner, "Lobby holds " + ((Plugin.LobbySize.Value > 0) ? (Plugin.LobbySize.Value + " (raised)") : "whatever the game says"), "Click to raise it to 12, or back to the game's own number. Both gates get raised - FishNet's client cap and the Steam lobby's member limit - because whichever is lower is the real one. Takes effect on this lobby immediately; the game was balanced around its own number, so watch for missing spawn points or boat seats.", delegate
			{
				Plugin.LobbySize.Value = ((Plugin.LobbySize.Value <= 0) ? 12 : 0);
				return (Plugin.LobbySize.Value == 0) ? "Back to the game's own lobby size (needs a new lobby)." : (Lobby.Widen() ?? "Lobby size set to 12.");
			}, Plugin.LobbySize.Value > 0);
			Act(_guardInner, "Send the boss away", "Dismisses whatever boss is up, however it got there - somebody summoned it to grief the lobby, or the guard dropped it on them. Goes through the game's own KillBoss, so the health bar and the fight state go with it.", () => Actions.SendBossAway());
			Act(_guardInner, "Clear all duplicates", "Despawns every spare body in the lobby. Clone spammers leave copies behind that make names impossible to tell apart.", () => Actions.PurgeAll());
			Act(_guardInner, Extras.ChumOut ? "Pick the chum back up" : "Drop chum", "Bait dropped somewhere only a flyer can reach. Anyone who gets to it was not walking.", delegate
			{
				if (!Extras.ChumOut)
				{
					return Extras.DropChum();
				}
				Extras.ClearChum();
				return "Chum picked back up.";
			}, Extras.ChumOut);
		}

		private static void BuildSettingsTab()
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			string text = "SETTINGS";
			for (int i = 0; i < _tools.Length; i++)
			{
				ScrollRect scroll;
				Transform parent = Column(_body, (i == 0) ? text : "", 1f, out scroll);
				_tools[i] = NativeUI.Group(parent, Theme.EdgeWarden);
				_fill[i] = 0f;
			}
			_fill[0] = 60f;
			_at = 0;
			_setInner = _tools[0];
			BuildSettings();
		}

		private static void BuildSettings()
		{
			Section("WHAT IT COSTS");
			Choice(_setInner, "Proven cheating", Policy.Proven, Policy.SetProven, "Something the vanilla client could not have sent. There is no innocent explanation for these.");
			Choice(_setInner, "Suspicious", Policy.Suspicious, Policy.SetSuspicious, "Something a laggy or unlucky player could trip. Removing on these is how an innocent stranger gets kicked.");
			Note(_setInner, "A hunch is only ever written down, whatever these say.");
			List<string> list = Cases.NoisyRules().ToList();
			List<string> list2 = Rules.Disabled.ToList();
			if (list.Count > 0 || list2.Count > 0)
			{
				Section("RULES");
				foreach (string item in list)
				{
					string name = item;
					Act(_setInner, "Stop checking " + name, "This rule has been dismissed more than once, which usually means it is catching something innocent. Switching it off stops the false alarms.", () => (!Rules.Disable(name)) ? (name + " was already off.") : (name + " switched off."));
				}
				foreach (string item2 in list2)
				{
					string name2 = item2;
					Act(_setInner, "Check " + name2 + " again", "Switches this rule back on.", () => (!Rules.Enable(name2)) ? (name2 + " was already on.") : (name2 + " switched back on."), on: true);
				}
			}
			Section("LOOK THINGS UP");
			Act(_setInner, "What everyone has tried", "A summary of every rule that has fired this session and who set it off. Goes to chat.", delegate
			{
				foreach (string item3 in Summary.Lines())
				{
					Chat.Info(item3);
				}
				return "Summary is in the chat.";
			});
			Act(_setInner, "Recent findings", "The last few things the guard wrote down. Goes to chat.", delegate
			{
				List<Entry> list4 = Logbook.Tail(8);
				if (list4.Count == 0)
				{
					return "The logbook is empty.";
				}
				foreach (Entry item4 in list4)
				{
					Chat.Info(item4.Line);
				}
				return list4.Count + " in the chat.";
			});
			Act(_setInner, "Everyone banned  (" + Bans.Count + ")", "The trophy wall - everyone the guard has landed, kept across sessions. Goes to chat.", delegate
			{
				if (Bans.Count == 0)
				{
					return "The trophy wall is empty.";
				}
				foreach (Bans.Record item5 in Bans.All.Take(12))
				{
					Chat.Info("  " + item5.Name + " - " + item5.Reason);
				}
				return Bans.Count + " on the wall, in the chat.";
			});
			foreach (Bans.Record item6 in Bans.All.Take(6).ToList())
			{
				ulong id = item6.SteamId;
				string nm = item6.Name;
				Act(_setInner, "Let " + nm + " back in", "Takes them off the trophy wall so they can rejoin.", delegate
				{
					Bans.Remove(id);
					return nm + " can rejoin.";
				});
			}
			Act(_setInner, "Save a file for the devs", "Writes everything this session saw to a text file, for reporting a hole in the game rather than a cheat.", delegate
			{
				try
				{
					Directory.CreateDirectory(Logbook.Folder);
					string text = Path.Combine(Logbook.Folder, "report_" + DateTime.Now.ToString("yyyy-MM-dd_HHmmss") + ".txt");
					File.WriteAllText(text, Logbook.Report());
					return "Written to " + text;
				}
				catch (Exception ex)
				{
					return "Could not write the report: " + ex.Message;
				}
			});
			Act(_setInner, "Where is everybody", "Writes each player's position, read three different ways, to the log. This answers whether freeze, strip and blowback are reading the right one - the spawn code was reading the wrong one and put everything at the map centre.", () => Body.Survey());
			Act(_setInner, "Check the guard is behaving", "Runs the self-test: every rule against known-good and known-bad input, so you can see it is not just quiet.", delegate
			{
				foreach (string item7 in SelfTest.Run())
				{
					Chat.Info(item7);
				}
				return "Self-test is in the chat.";
			});
			List<string> list3 = Rules.Known.ToList();
			int disabledCount = Rules.DisabledCount;
			Act(_setInner, (_showRules ? "Hide the checks" : ("Every check  (" + list3.Count + ")")) + ((disabledCount > 0) ? ("   -   " + disabledCount + " switched off") : ""), "Each of these is one thing the guard looks for. Switching one off stops that check and nothing else, which is what you want when a single rule is crying wolf.", delegate
			{
				_showRules = !_showRules;
				return (!_showRules) ? "Folded away." : "Showing every check.";
			}, disabledCount > 0);
			if (_showRules)
			{
				Transform[] array = Tiles(_setInner, 3);
				for (int num = 0; num < list3.Count; num++)
				{
					string name3 = list3[num];
					bool on = Rules.Enabled(name3);
					bool flag = Response.Blocks(name3);
					bool flag2 = Response.Trolls(name3);
					Transform parent = array[num % array.Length];
					Act(parent, name3.Replace("-", " ") + (on ? ("   " + (flag ? "refused" : "watched") + (flag2 ? " + answered" : "")) : ""), on ? ("Checked. " + (flag ? "The packet is refused. " : "Recorded only. ") + (flag2 ? "They get answered for it." : "No response is aimed at them.") + "  Click to stop checking it entirely.") : "NOT checked - this is switched off. Click to switch it back on.", delegate
					{
						if (!on)
						{
							if (!Rules.Enable(name3))
							{
								return name3 + " was already on.";
							}
							return name3 + " switched back on.";
						}
						return (!Rules.Disable(name3)) ? (name3 + " was already off.") : (name3 + " switched off.");
					}, on);
					if (on)
					{
						Act(parent, flag ? "     refuse it: yes" : "     refuse it: no", "Whether the packet is dropped, or the finding is only written down. Refusing costs an innocent player one lost action; it is the cheap half.", () => Response.Toggle(name3, troll: false), flag);
						Act(parent, flag2 ? "     answer them: yes" : "     answer them: no", "Whether they get a matched response in front of the lobby - the gun goes off in their hands, they drop what they hold, they end up out to sea. This is the expensive half: it costs them their standing, so it is off by default for anything measured.", () => Response.Toggle(name3, troll: true), flag2);
					}
				}
			}
			Act(_setInner, Plugin.TraceUnguarded.Value ? "Stop logging everything" : "Log everything, to find a gap", "Writes down every packet the guard has no rule for. This is how a new exploit gets found - it is noisy, so it is off unless you are hunting.", delegate
			{
				Plugin.TraceUnguarded.Value = !Plugin.TraceUnguarded.Value;
				return (!Plugin.TraceUnguarded.Value) ? "Tracing off." : "Tracing. Check the log.";
			}, Plugin.TraceUnguarded.Value);
		}

		private static void BuildTools()
		{
			//IL_0acd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0ae7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c1f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c39: Unknown result type (might be due to invalid IL or missing references)
			Section("PRIVATE - NOT IN THE PUBLIC BUILD");
			Act(_toolInner, "God mode", "Refuses damage aimed at you at the server, so you are not hit at all. Only works while you are the host, because that is the machine applying it.", delegate
			{
				Cheats.GodMode = !Cheats.GodMode;
				return (!Cheats.GodMode) ? "You can be hurt again." : "Nothing can hurt you.";
			}, Cheats.GodMode);
			Act(_toolInner, "Oops I Did It Again Jesus mode", "You still take the hit and still drop - this stands you back up a moment later. Works as a guest too, since resurrection never checks who asked.", delegate
			{
				Cheats.Immortal = !Cheats.Immortal;
				return (!Cheats.Immortal) ? "Staying down now." : "You will keep getting back up.";
			}, Cheats.Immortal);
			Act(_toolInner, "Endless ammo", "Never reload.", delegate
			{
				Cheats.InfiniteAmmo = !Cheats.InfiniteAmmo;
				return (!Cheats.InfiniteAmmo) ? "Reloading again." : "No reloading.";
			}, Cheats.InfiniteAmmo);
			Act(_toolInner, "One punch", "Your punches kill in one hit.", delegate
			{
				Cheats.OnePunch = !Cheats.OnePunch;
				return (!Cheats.OnePunch) ? "Normal punches." : "One punch.";
			}, Cheats.OnePunch);
			if (Cheats.OnePunch)
			{
				Dial(_toolInner, "Punch damage", Cheats.OnePunchForce, 1f, 999999f, delegate(float x)
				{
					Cheats.OnePunchForce = x;
				}, "0");
				Note(_toolInner, "A normal punch does whatever the game says - check the log for the vanilla number. This replaces it, for your punches only.");
			}
			Act(_toolInner, "Mr. Fantastic", "Punch from much further away than you should be able to.", delegate
			{
				Cheats.Stretchy = !Cheats.Stretchy;
				return (!Cheats.Stretchy) ? "Normal reach." : "Reach extended.";
			}, Cheats.Stretchy);
			Act(_toolInner, "Jesus mode", "The surface holds your weight.", delegate
			{
				Cheats.WalkOnWater = !Cheats.WalkOnWater;
				return (!Cheats.WalkOnWater) ? "You sink again." : "The surface holds.";
			}, Cheats.WalkOnWater);
			if (Cheats.Stretchy)
			{
				Dial(_toolInner, "Arm reach", Cheats.Reach, 2f, 60f, delegate(float x)
				{
					Cheats.Reach = x;
				}, "0");
			}
			Dial(_toolInner, "Money per sale", Cheats.MoneyMultiplier, 1f, 50f, delegate(float x)
			{
				Cheats.MoneyMultiplier = x;
			});
			Note(_toolInner, "Pays the extra when you sell. Nothing happens until then.");
			Dial(_toolInner, "Luck on the next catch", Cheats.LuckMultiplier, 1f, 20f, delegate(float x)
			{
				Cheats.LuckMultiplier = x;
			});
			Note(_toolInner, "Bends the catch table toward the rare end. Applies as you fish.");
			Dial(_toolInner, "Walking speed", Cheats.SpeedMultiplier, 1f, 20f, delegate(float x)
			{
				Cheats.SpeedMultiplier = x;
			});
			Section("AIM");
			Act(_toolInner, "Fish aimbot", "Turns the game's own controller aim assist into a full auto-aim on mouse and keyboard.", delegate
			{
				Kit.Aimbot = !Kit.Aimbot;
				return (!Kit.Aimbot) ? "Aim assist back to normal." : "Aim assist is yours now.";
			}, Kit.Aimbot);
			if (Kit.Aimbot)
			{
				Dial(_toolInner, "Cone", Kit.AimFov, 1f, 90f, delegate(float x)
				{
					Kit.AimFov = x;
				}, "0");
				Dial(_toolInner, "Range", Kit.AimRange, 10f, 600f, delegate(float x)
				{
					Kit.AimRange = x;
				}, "0");
				Dial(_toolInner, "Snap", Kit.AimSnap, 1f, 60f, delegate(float x)
				{
					Kit.AimSnap = x;
				}, "0");
			}
			Act(_toolInner, "Fisherman aimbot", "Steers your aim at PEOPLE instead of fish while aiming down sights.", delegate
			{
				Kit.ManHunt = !Kit.ManHunt;
				return (!Kit.ManHunt) ? "People are safe again." : "Tracking people, not fish.";
			}, Kit.ManHunt);
			if (Kit.ManHunt)
			{
				Dial(_toolInner, "Cone", Kit.ManFov, 1f, 180f, delegate(float x)
				{
					Kit.ManFov = x;
				}, "0");
				Dial(_toolInner, "Snap", Kit.ManSnap, 1f, 60f, delegate(float x)
				{
					Kit.ManSnap = x;
				}, "0");
			}
			Act(_toolInner, "Laser gun", "No cooldown, no recoil, dead straight. Every gun becomes a continuous stream.", delegate
			{
				Kit.Laser = !Kit.Laser;
				return (!Kit.Laser) ? "Guns behave themselves." : "No cooldown, no recoil, straight line.";
			}, Kit.Laser);
			Act(_toolInner, "Smite whoever you are looking at", "Kills whoever is in your crosshair, even with friendly fire off.", () => Smite.Strike());
			Section("MOVEMENT");
			Act(_toolInner, "Bunny hop", "Hold space to keep bouncing instead of jumping once.", delegate
			{
				Kit.BunnyHop = !Kit.BunnyHop;
				return (!Kit.BunnyHop) ? "Normal jumping." : "Hold space to keep bouncing.";
			}, Kit.BunnyHop);
			Section("BOSSES");
			Act(_toolInner, "Boss on every cast", "Every single cast hooks the boss instead of a fish.", delegate
			{
				Kit.BossRush = !Kit.BossRush;
				return (!Kit.BossRush) ? "Fishing is fishing again." : ("Every cast hooks " + Kit.BossName + ".");
			}, Kit.BossRush);
			if (Kit.BossRush)
			{
				List<string> bosses = Kit.BossNames();
				if (bosses.Count > 0)
				{
					Act(_toolInner, "Target: " + Kit.BossName + "   -   next", "Which boss every cast should hook. Click to move to the next one.", delegate
					{
						int num = bosses.FindIndex((string b) => b.IndexOf(Kit.BossName, StringComparison.OrdinalIgnoreCase) >= 0);
						Kit.BossName = bosses[(num + 1 + bosses.Count) % bosses.Count];
						return "Now hooking " + Kit.BossName + ".";
					});
				}
			}
			Act(_toolInner, "Summon the magma whale", "Spawns the final boss in front of you. Erupts the volcano properly if you are on the lava island.", () => Kit.SummonWhale());
			Act(_toolInner, "Take back everything I spawned  (" + Cheats.SpawnedCount + ")", "Despawns every creature and item spawned from this console, boss or not. Sending the boss away only removes the one the fight is built around; spawn three whales and the other two are not bosses as far as the game is concerned, and nothing but this knows they are there.", () => Cheats.ClearSpawned());
			Act(_toolInner, "Send the boss away", "Despawns a boss you summoned, through the game's own KillBoss - so the health bar and the fight state go with it.", () => Actions.SendBossAway());
			Dial(_toolInner, "Whale distance", Kit.WhaleDistance, 10f, 150f, delegate(float x)
			{
				Kit.WhaleDistance = x;
			}, "0");
			Section("MONEY");
			Dial(_toolInner, "Worth multiplier", Kit.WorthMultiplier, 1f, 10000f, delegate(float x)
			{
				Kit.WorthMultiplier = x;
			}, "0");
			Act(_toolInner, "Inflate everything you carry  x" + Kit.WorthMultiplier.ToString("0"), "Sets what everything you are carrying sells for - what is in your hands and everything in the inventory behind it - using the multiplier above. The slider on its own does nothing; this is the row that applies it. Works once per item, so sell them before inflating more.", () => Kit.InflateHeld());
			Act(_toolInner, "Dripper: " + Kit.CasinoLabel(), "Rigs the slot machine to land on the rarity you pick. Click to cycle: off, green, rare, legendary.", () => Kit.CycleCasino(), !Kit.CasinoLabel().Equals("off", StringComparison.OrdinalIgnoreCase));
			Act(_toolInner, "Roulette: " + Kit.RouletteLabel(), "Rigs the red/black/green wheel. Green pays 35x. Click to cycle the winning colour.", () => Kit.CycleRoulette(), Kit.Roulette);
			Act(_toolInner, "Dripper takes anything", "The slot machine will swallow clams and ordinary items, not just drip creatures.", delegate
			{
				Kit.DripperTakesAnything = !Kit.DripperTakesAnything;
				return (!Kit.DripperTakesAnything) ? "Drip creatures only, as intended." : "It will swallow clams now.";
			}, Kit.DripperTakesAnything);
			Section("SEEING AND OWNING");
			Act(_toolInner, "See further", "Thins the fog and pushes the view distance out. Useful for spotting people who should not be where they are.", delegate
			{
				Kit.Visibility = !Kit.Visibility;
				return (!Kit.Visibility) ? "Fog back to normal." : "Fog thinned, view distance pushed out.";
			}, Kit.Visibility);
			if (Kit.Visibility)
			{
				Dial(_toolInner, "Fog", Kit.FogMultiplier, 0f, 1f, delegate(float x)
				{
					Kit.FogMultiplier = x;
				}, "0.00");
				Dial(_toolInner, "View distance", Kit.ViewDistance, 500f, 10000f, delegate(float x)
				{
					Kit.ViewDistance = x;
				}, "0");
			}
			Act(_toolInner, "Show every island", "Puts every island on the radar, including the hidden dev one.", delegate
			{
				Kit.RevealIslands = !Kit.RevealIslands;
				return (!Kit.RevealIslands) ? "Radar back to what you have unlocked." : "Every island on the radar, and you can sail to them.";
			}, Kit.RevealIslands);
			if (Kit.RevealIslands)
			{
				Act(_toolInner, "Let you sail there too", "Showing a dot is not permission to travel; this unlocks the travel gate as well.", delegate
				{
					Kit.UnlockTravel = !Kit.UnlockTravel;
					return (!Kit.UnlockTravel) ? "Dots only." : "Travel unlocked.";
				}, Kit.UnlockTravel);
			}
			Act(_toolInner, "Unlock every skin", "Unlocks all clothing, item and boat skins. Adds without wiping, so nothing you own is lost.", () => Kit.UnlockEverything());
			Section("YOUR TOOLS");
			Act(_toolInner, (HostTools.Flying ? "Stop flying" : "Fly") + Plugin.KeyLabel("Fly"), "Free movement in three dimensions. Space and control for up and down.", () => HostTools.ToggleFly(), HostTools.Flying);
			Act(_toolInner, "Previous island" + Plugin.KeyLabel("PrevIsland"), "Travels the WHOLE lobby to the island before this one.", () => HostTools.Next(backwards: true));
			Act(_toolInner, "Next island" + Plugin.KeyLabel("NextIsland"), "Travels the WHOLE lobby to the next island.", () => HostTools.Next(backwards: false));
			TMP_Text val = NativeUI.Label(_toolInner, HostTools.Where(), Vector2.zero);
			if ((Object)(object)val != (Object)null)
			{
				((Graphic)val).color = Theme.Faint;
				Fix(val, 20f, (TextAlignmentOptions)513);
			}
			Dial(_toolInner, "Fly speed", Plugin.FlySpeed.Value, 5f, 80f, delegate(float x)
			{
				Plugin.FlySpeed.Value = x;
			}, "0");
			Dial(_toolInner, "Shift boost", Plugin.FlyBoost.Value, 1f, 10f, delegate(float x)
			{
				Plugin.FlyBoost.Value = x;
			});
			Section("VANILLA BUG FIXES");
			Act(_toolInner, "Fix black screen on join", "A bug in the base game where joining players see nothing. Leave it on.", delegate
			{
				Plugin.FixJoining.Value = !Plugin.FixJoining.Value;
				return (!Plugin.FixJoining.Value) ? "Join fix off." : "Join fix on.";
			}, Plugin.FixJoining.Value);
			Act(_toolInner, "Fix the sinking boat", "A bug in the base game where a broken player drags the boat under. Leave it on.", delegate
			{
				Plugin.PruneBrokenPlayers.Value = !Plugin.PruneBrokenPlayers.Value;
				return (!Plugin.PruneBrokenPlayers.Value) ? "Boat fix off." : "Boat fix on.";
			}, Plugin.PruneBrokenPlayers.Value);
			TMP_Text val2 = NativeUI.Label(_toolInner, "Both are bugs in the base game. Leave them on.", Vector2.zero);
			if ((Object)(object)val2 != (Object)null)
			{
				((Graphic)val2).color = Theme.Faint;
				Fix(val2, 22f, (TextAlignmentOptions)513);
			}
			List<string> list = Cheats.Names("");
			List<string> list2 = Cheats.Names(_spawnQuery);
			Section(string.IsNullOrEmpty(_spawnQuery) ? ("SPAWN  (" + list.Count + ")") : ("SPAWN  (" + list2.Count + " of " + list.Count + ")"));
			_search = NativeUI.Field(_toolInner, "Type to search " + list.Count + " things...", _spawnQuery, delegate(string s)
			{
				if (!(s == _spawnQuery))
				{
					_spawnQuery = s;
					_spawnPage = 0;
					_searchSettles = Time.realtimeSinceStartup + 0.25f;
				}
			});
			if ((Object)(object)_search == (Object)null)
			{
				int pages = Mathf.Max(1, Mathf.CeilToInt((float)list2.Count / 40f));
				_spawnPage = Mathf.Clamp(_spawnPage, 0, pages - 1);
				if (pages > 1)
				{
					Act(_toolInner, "Page " + (_spawnPage + 1) + " of " + pages + "   -   next", "The spawn list is long, so it is shown forty at a time. Click for the next forty.", delegate
					{
						_spawnPage = (_spawnPage + 1) % pages;
						return "Showing page " + (_spawnPage + 1) + ".";
					});
				}
				{
					foreach (string item in list2.Skip(_spawnPage * 40).Take(40))
					{
						string pick = item;
						Act(_toolInner, pick, "Spawns one of these in front of you.", () => Cheats.Spawn(pick));
					}
					return;
				}
			}
			if (string.IsNullOrEmpty(_spawnQuery))
			{
				Note(_toolInner, "Start typing above and matches appear here.");
				return;
			}
			if (list2.Count == 0)
			{
				Note(_toolInner, "Nothing matches \"" + _spawnQuery + "\".");
				return;
			}
			foreach (string item2 in list2.Take(25))
			{
				string pick2 = item2;
				Act(_toolInner, pick2, "Spawns one of these in front of you.", () => Cheats.Spawn(pick2));
			}
			if (list2.Count > 25)
			{
				Note(_toolInner, "...and " + (list2.Count - 25) + " more. Type a bit more to narrow it down.");
			}
		}

		private static void UpdateDossier()
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: 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)
			if ((Object)(object)_dossier == (Object)null)
			{
				return;
			}
			Player val = Selected();
			if ((Object)(object)val == (Object)null)
			{
				NativeUI.Say(_dossier, "Pick somebody on the left to see what they have been doing.");
				((Graphic)_dossier).color = Theme.Faint;
				return;
			}
			int value;
			int num = (Logbook.Tally().TryGetValue(_selected, out value) ? value : 0);
			List<string> list = Summary.LinesFor(_selected);
			string text = val.SteamName + "\n" + ((num == 0) ? "nothing against them" : (num + " strikes, " + Summary.ProvenCount(_selected) + " proven"));
			if (list.Count > 0)
			{
				text = text + "\n" + string.Join("\n", list.Take(4));
			}
			NativeUI.Say(_dossier, text);
			((Graphic)_dossier).color = ((num == 0) ? Theme.Muted : Theme.ForStrikes(num, Plugin.KickThreshold.Value));
		}

		private static void Grave(Transform parent, string label, string ask, string hint, Func<string> run)
		{
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: 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_009a: 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)
			bool flag = _armed == label && Time.realtimeSinceStartup < _armedUntil;
			GameObject go = NativeUI.Button(parent, flag ? ask : label, delegate
			{
				if (_armed == label && Time.realtimeSinceStartup < _armedUntil)
				{
					_armed = null;
					string text = run();
					Plugin.Log.LogInfo((object)("[Console] confirmed \"" + label + "\" -> " + (text ?? "(no message)")));
					Toast(text);
					Mark();
				}
				else
				{
					_armed = label;
					_armedUntil = Time.realtimeSinceStartup + 5f;
					Toast(ask + "  Click again to confirm.");
					Mark();
				}
			}, new Vector2(0f, 40f), Vector2.zero, hint + "  This cannot be undone, so it asks once first.");
			NativeUI.Edge(go, flag ? Theme.EdgeGrave : Theme.EdgeGrave);
			NativeUI.Back(go, flag ? Theme.RowArmed : Theme.Row);
			if (flag)
			{
				NativeUI.Paint(go, Theme.Ink);
			}
			Grew(parent, 44f);
		}

		private static void Act(Transform parent, string label, string hint, Func<string> run, bool on = false)
		{
			//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)
			GameObject go = NativeUI.Button(parent, (on ? "✓  " : "") + label, delegate
			{
				string text = run();
				Plugin.Log.LogInfo((object)("[Console] clicked \"" + label + "\" -> " + (string.IsNullOrEmpty(text) ? "(no message)" : text)));
				Toast(text);
				Mark();
			}, new Vector2(0f, 40f), Vector2.zero, hint);
			if (on)
			{
				NativeUI.Mark(go, on: true);
			}
			Grew(parent, 44f);
		}

		private static void Choice(Transform parent, string what, Action now, Action<Action> set, string hint)
		{
			//IL_001b: 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_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0125: 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)
			TMP_Text val = NativeUI.Label(parent, what, Vector2.zero);
			if ((Object)(object)val != (Object)null)
			{
				((Graphic)val).color = Theme.Muted;
				Fix(val, 22f, (TextAlignmentOptions)513);
			}
			GameObject val2 = Strip(parent, what, 40f);
			foreach (Action value in Enum.GetValues(typeof(Action)))
			{
				Action mine = value;
				bool flag = now == value;
				GameObject val3 = NativeUI.Button(val2.transform, (flag ? "✓ " : "   ") + Policy.Costs(value), delegate
				{
					set(mine);
					Toast(what + ": " + Policy.Costs(mine).ToLowerInvariant() + ".");
					Mark();
				}, new Vector2(0f, 40f), Vector2.zero, hint);
				(val3.GetComponent<LayoutElement>() ?? val3.AddComponent<LayoutElement>()).flexibleWidth = 1f;
				NativeUI.Mark(val3, flag);
				NativeUI.Edge(val3, flag ? Theme.EdgeLive : Theme.EdgeIdle);
			}
			Grew(parent, 88f);
		}

		private static Transform[] Tiles(Transform parent, int n)
		{
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Expected O, but got Unknown
			GameObject val = Strip(parent, "Tiles", 0f);
			LayoutElement component = val.GetComponent<LayoutElement>();
			component.preferredHeight = -1f;
			component.flexibleHeight = 0f;
			HorizontalLayoutGroup component2 = val.GetComponent<HorizontalLayoutGroup>();
			((HorizontalOrVerticalLayoutGroup)component2).spacing = 6f;
			((HorizontalOrVerticalLayoutGroup)component2).childForceExpandHeight = false;
			((LayoutGroup)component2).childAlignment = (TextAnchor)0;
			Transform[] array = (Transform[])(object)new Transform[n];
			for (int i = 0; i < n; i++)
			{
				GameObject val2 = new GameObject("Tile", new Type[3]
				{
					typeof(RectTransform),
					typeof(VerticalLayoutGroup),
					typeof(LayoutElement)
				});
				val2.transform.SetParent(val.transform, false);
				VerticalLayoutGroup component3 = val2.GetComponent<VerticalLayoutGroup>();
				((HorizontalOrVerticalLayoutGroup)component3).spacing = 4f;
				((HorizontalOrVerticalLayoutGroup)component3).childControlWidth = true;
				((HorizontalOrVerticalLayoutGroup)component3).childControlHeight = true;
				((HorizontalOrVerticalLayoutGroup)component3).childForceExpandHeight = false;
				((HorizontalOrVerticalLayoutGroup)component3).childForceExpandWidth = true;
				LayoutElement component4 = val2.GetComponent<LayoutElement>();
				component4.flexibleWidth = 1f;
				component4.preferredWidth = 0f;
				array[i] = val2.transform;
			}
			return array;
		}

		private static void Charges(Player p)
		{
			ulong steamID;
			try
			{
				steamID = p.SteamID;
			}
			catch
			{
				return;
			}
			List<Entry> list;
			try
			{
				list = Logbook.EntriesFor(steamID, Plugin.ChargesShown.Value);
			}
			catch
			{
				return;
			}
			if (list == null || list.Count == 0)
			{
				Note(_wardenInner, "Nothing on them. The guard has not caught them at anything.");
				return;
			}
			for (int num = list.Count - 1; num >= 0; num--)
			{
				Entry entry = list[num];
				if (entry != null)
				{
					string text = (string.IsNullOrEmpty(entry.Verdict.Rule) ? entry.Rpc : entry.Verdict.Rule);
					Note(_wardenInner, entry.When.ToString("HH:mm", CultureInfo.InvariantCulture) + "  " + text + (entry.Blocked ? "  (blocked)" : "  (allowed)"));
					if (!string.IsNullOrEmpty(entry.Verdict.Detail))
					{
						Note(_wardenInner, "      " + entry.Verdict.Detail);
					}
				}
			}
			Entry entry2 = list[list.Count - 1];
			if (entry2 != null && entry2.Verdict.Rule != null)
			{
				Note(_wardenInner, "Latest is " + Response.FamilyOf(entry2.Verdict.Rule).ToString().ToLowerInvariant() + (Response.Trolls(entry2.Verdict.Rule) ? ", answers back." : ", never answers back."));
			}
		}

		private static void Note(Transform parent, string text)
		{
			//IL_0002: 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)
			TMP_Text val = NativeUI.Label(parent, text, Vector2.zero);
			if (!((Object)(object)val == (Object)null))
			{
				((Graphic)val).color = Theme.Faint;
				Fix(val, 24f, (TextAlignmentOptions)513);
				Grew(parent, 28f);
			}
		}

		private static void Dial(Transform parent, string label, float value, float min, float max, Action<float> set, string format = "0.0", bool whole = false)
		{
			NativeUI.Slider(parent, label, value, min, max, set, format, whole);
			Grew(parent, 66f);
		}

		private static float Where(ScrollRect s)
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				return ((Object)(object)s == (Object)null || (Object)(object)s.content == (Object)null) ? 0f : s.content.anchoredPosition.y;
			}
			catch
			{
				return 0f;
			}
		}

		private static void Restore(ScrollRect s, float at)
		{
			//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_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_0068: 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_0087: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if (!((Object)(object)s == (Object)null) && !((Object)(object)s.content == (Object)null))
				{
					float num;
					Rect rect;
					if (!((Object)(object)s.viewport != (Object)null))
					{
						num = 0f;
					}
					else
					{
						rect = s.viewport.rect;
						num = ((Rect)(ref rect)).height;
					}
					float num2 = num;
					rect = s.content.rect;
					float num3 = Mathf.Max(0f, ((Rect)(ref rect)).height - num2);
					Vector2 anchoredPosition = s.content.anchoredPosition;
					anchoredPosition.y = Mathf.Clamp(at, 0f, num3);
					s.content.anchoredPosition = anchoredPosition;
				}
			}
			catch
			{
			}
		}

		private static void Clear(Transform t)
		{
			if (!((Object)(object)t == (Object)null))
			{
				for (int num = t.childCount - 1; num >= 0; num--)
				{
					GameObject gameObject = ((Component)t.GetChild(num)).gameObject;
					gameObject.transform.SetParent((Transform)null, false);
					Object.Destroy((Object)(object)gameObject);
				}
			}
		}

		private static void Fix(TMP_Text t, float height, TextAlignmentOptions align)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)t == (Object)null))
			{
				NativeUI.Sizing(((Component)t).gameObject, height);
				t.textWrappingMode = (TextWrappingModes)1;
				t.alignment = align;
			}
		}

		private static List<Player> Others()
		{
			List<Player> list = new List<Player>();
			try
			{
				foreach (Player player in PlayerManager.Players)
				{
					if ((Object)(object)player != (Object)null && (Object)(object)player != (Object)(object)Player.LocalPlayer)
					{
						list.Add(player);
					}
				}
			}
			catch
			{
			}
			return list;
		}

		private static Player Selected()
		{
			if (_selected == 0L)
			{
				return null;
			}
			foreach (Player item in Others())
			{
				try
				{
					if (item.SteamID == _selected)
					{
						return item;
					}
				}
				catch
				{
				}
			}
			return null;
		}
	}
	internal static class NativeLook
	{
		private static bool _looked;

		private static Font _font;

		private static bool _sampled;

		public static Font Font
		{
			get
			{
				Look();
				return _font;
			}
		}

		public static string Source { get; private set; } = "not looked yet";

		public static Color MenuText { get; private set; } = Color.white;

		public static bool MenuBold { get; private set; } = true;

		public static int MenuSize { get; private set; } = 16;

		public static void SampleMenu()
		{
			//IL_0117: 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_011f: Invalid comparison between Unknown and I4
			//IL_0128: 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_012f: Unknown result type (might be due to invalid IL or missing references)
			//IL_013d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0144: 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_0157: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dc: Unknown result type (might be due to invalid IL or missing references)
			if (_sampled)
			{
				return;
			}
			try
			{
				PauseManager val = Object.FindAnyObjectByType<PauseManager>();
				if ((Object)(object)val == (Object)null)
				{
					return;
				}
				object value = Traverse.Create((object)val).Field("_pauseHolder").GetValue();
				GameObject val2 = (GameObject)(((value is GameObject) ? value : null) ?? ((object)/*isinst with value type is only supported in some contexts*/));
				if ((Object)(object)val2 == (Object)null)
				{
					return;
				}
				TMP_Text[] componentsInChildren = val2.GetComponentsInChildren<TMP_Text>(true);
				if (componentsInChildren == null || componentsInChildren.Length == 0)
				{
					return;
				}
				IGrouping<int, TMP_Text> grouping = (from t in componentsInChildren
					where (Object)(object)t != (Object)null && t.fontSize > 4f
					group t by Mathf.RoundToInt(t.fontSize) into g
					orderby g.Count() descending
					select g).FirstOrDefault();
				if (grouping != null)
				{
					TMP_Text val3 = grouping.First();
					MenuSize = Mathf.Clamp(Mathf.RoundToInt(val3.fontSize), 11, 22);
					MenuBold = (val3.fontStyle & 1) > 0;
					Color color = ((Graphic)val3).color;
					if (color.a > 0.2f)
					{
						MenuText = new Color(color.r, color.g, color.b, 1f);
					}
					if ((Object)(object)val3.font != (Object)null && (Object)(object)val3.font.sourceFontFile != (Object)null)
					{
						_font = val3.font.sourceFontFile;
						_looked = true;
						Source = "pause menu";
					}
					_sampled = true;
					Plugin.Log.LogInfo((object)($"[Theme] matched the escape menu: size {MenuSize}, " + (MenuBold ? "bold" : "regular") + ", " + ColorUtility.ToHtmlStringRGB(MenuText)));
				}
			}
			catch
			{
			}
		}

		private static void Look()
		{
			if (_looked)
			{
				return;
			}
			try
			{
				_font = FromLocalization() ?? FromAnyTmpAsset() ?? FromLoadedFonts();
				if ((Object)(object)_font != (Object)null)
				{
					_looked = true;
					Plugin.Log.LogInfo((object)("[Theme] using the game's font: " + ((Object)_font).name + " (" + Source + ")"));
				}
			}
			catch (Exception ex)
			{
				_looked = true;
				Source = "failed: " + ex.Message;
				Plugin.Log.LogWarning((object)("[Theme] could not borrow a font, using the default: " + ex.Message));
			}
		}

		private static Font FromLocalization()
		{
			try
			{
				LocalizationManager val = Object.FindAnyObjectByType<LocalizationManager>();
				if ((Object)(object)val == (Object)null)
				{
					return null;
				}
				string[] array = new string[2] { "_defaultFontAsset", "_backdropFontAsset" };
				foreach (string text in array)
				{
					Traverse val2 = Traverse.Create((object)val).Field(text);
					if (val2 != null && val2.FieldExists())
					{
						object value = val2.GetValue();
						TMP_FontAsset val3 = (TMP_FontAsset)((value is TMP_FontAsset) ? value : null);
						Font val4 = (((Object)(object)val3 != (Object)null) ? val3.sourceFontFile : null);
						if ((Object)(object)val4 != (Object)null)
						{
							Source = "LocalizationManager." + text;
							return val4;
						}
					}
				}
			}
			catch
			{
			}
			return null;
		}

		private static Font FromAnyTmpAsset()
		{
			try
			{
				TMP_FontAsset[] array = Resources.FindObjectsOfTypeAll<TMP_FontAsset>();
				foreach (TMP_FontAsset val in array)
				{
					if (!((Object)(object)val == (Object)null))
					{
						Font sourceFontFile = val.sourceFontFile;
						if ((Object)(object)sourceFontFile != (Object)null)
						{
							Source = "TMP asset " + ((Object)val).name;
							return sourceFontFile;
						}
					}
				}
			}
			catch
			{
			}
			return null;
		}

		private static Font FromLoadedFonts()
		{
			try
			{
				List<Font> list = (from f in Resources.FindObjectsOfTypeAll<Font>()
					where (Object)(object)f != (Object)null && !string.IsNullOrEmpty(((Object)f).name)
					where ((Object)f).name.IndexOf("Arial", StringComparison.OrdinalIgnoreCase) < 0
					select f).ToList();
				if (list.Count > 0)
				{
					Source = "loaded font " + ((Object)list[0]).name;
					return list[0];
				}
			}
			catch
			{
			}
			return null;
		}
	}
	internal sealed class NativeScroll : MonoBehaviour, IScrollHandler, IEventSystemHandler
	{
		public ScrollRect Rect;

		public void OnScroll(PointerEventData e)
		{
			//IL_0023: 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_0066: 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_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: 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_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)Rect == (Object)null || (Object)(object)Rect.content == (Object)null)
			{
				return;
			}
			float y = e.scrollDelta.y;
			if (!(Mathf.Abs(y) < 0.0001f))
			{
				float num;
				Rect rect;
				if (!((Object)(object)Rect.viewport != (Object)null))
				{
					num = 0f;
				}
				else
				{
					rect = Rect.viewport.rect;
					num = ((Rect)(ref rect)).height;
				}
				float num2 = num;
				rect = Rect.content.rect;
				float num3 = Mathf.Max(0f, ((Rect)(ref rect)).height - num2);
				if (!(num3 <= 0f))
				{
					float num4 = Mathf.Max(120f, num2 * 0.25f);
					Vector2 anchoredPosition = Rect.content.anchoredPosition;
					anchoredPosition.y = Mathf.Clamp(anchoredPosition.y - Mathf.Sign(y) * num4, 0f, num3);
					Rect.content.anchoredPosition = anchoredPosition;
					Rect.velocity = Vector2.zero;
				}
			}
		}
	}
	internal static class NativeUI
	{
		internal sealed class Dial
		{
			public TMP_Text Caption;

			public Slider Bar;

			public string Format = "0.0";

			public string Label = "";

			public float Value;

			public void Sync()
			{
				Say(Caption, Label + "   " + Value.ToString(Format));
			}
		}

		public const float Row = 40f;

		private static GameObject _buttonTemplate;

		private static Transform _canvas;

		private static GameObject _root;

		private static GameObject _sliderTemplate;

		private static GameObject _ours;

		private static Material _glass;

		private static readonly Dictionary<TMP_Text, string> _pinned = new Dictionary<TMP_Text, string>();

		public static Action<string> OnHover;

		private static GameObject _fieldTemplate;

		private const float BarWidth = 12f;

		public static bool Available { get; private set; }

		public static string Problem { get; private set; } = "not looked yet";

		public static bool Prepare()
		{
			//IL_016b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0170: Unknown result type (might be due to invalid IL or missing references)
			//IL_0193: 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)
			if (Available)
			{
				return true;
			}
			try
			{
				CanvasManager val = Object.FindAnyObjectByType<CanvasManager>();
				if ((Object)(object)val == (Object)null)
				{
					Problem = "CanvasManager not in the scene yet";
					return false;
				}
				_buttonTemplate = PickButton(Traverse.Create((object)val).Field("_allMainMenuButtons").GetValue() as List<GameObject>);
				if ((Object)(object)_buttonTemplate == (Object)null)
				{
					_buttonTemplate = PickButton(from b in Resources.FindObjectsOfTypeAll<Button>().Where(delegate(Button b)
						{
							//IL_000f: 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)b != (Object)null)
							{
								Scene scene = ((Component)b).gameObject.scene;
								return ((Scene)(ref scene)).IsValid();
							}
							return false;
						})
						select ((Component)b).gameObject);
				}
				if ((Object)(object)_buttonTemplate == (Object)null)
				{
					Problem = "no menu button to copy";
					return false;
				}
				_canvas = ActiveCanvas();
				if ((Object)(object)_canvas == (Object)null)
				{
					Problem = "no active canvas to draw on";
					return false;
				}
				Available = true;
				Problem = null;
				TMP_Text componentInChildren = _buttonTemplate.GetComponentInChildren<TMP_Text>(true);
				Transform transform = _buttonTemplate.transform;
				RectTransform val2 = (RectTransform)(object)((transform is RectTransform) ? transform : null);
				ManualLogSource log = Plugin.Log;
				string[] obj = new string[6]
				{
					"[NativeUI] cloning '",
					((Object)_buttonTemplate).name,
					"'",
					null,
					null,
					null
				};
				object obj2;
				if (!((Object)(object)val2 != (Object)null))
				{
					obj2 = "";
				}
				else
				{
					string[] obj3 = new string[5] { " [", null, null, null, null };
					Rect rect = val2.rect;
					obj3[1] = ((Rect)(ref rect)).width.ToString("0");
					obj3[2] = "x";
					rect = val2.rect;
					obj3[3] = ((Rect)(ref rect)).height.ToString("0");
					obj3[4] = "]";
					obj2 = string.Concat(obj3);
				}
				obj[3] = (string)obj2;
				obj[4] = (((Object)(object)componentInChildren != (Object)null) ? (" (it reads \"" + componentInChildren.text + "\")") : "");
				obj[5] = " from the game's own menu.";
				log.LogInfo((object)string.Concat(obj));
				Describe(_buttonTemplate);
				return true;
			}
			catch (Exception ex)
			{
				Problem = ex.Message;
				return false;
			}
		}

		private static GameObject PickButton(IEnumerable<GameObject> candidates)
		{
			//IL_0132: 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_0144: Unknown result type (might be due to invalid IL or missing references)
			//IL_0149: Unknown result type (might be due to invalid IL or missing references)
			if (candidates == null)
			{
				return null;
			}
			List<GameObject> list = new List<GameObject>();
			foreach (GameObject candidate in candidates)
			{
				if ((Object)(object)candidate == (Object)null)
				{
					continue;
				}
				if ((Object)(object)candidate.GetComponent<Button>() != (Object)null)
				{
					list.Add(candidate);
					continue;
				}
				Button[] componentsInChildren = candidate.GetComponentsInChildren<Button>(true);
				foreach (Button val in componentsInChildren)
				{
					if ((Object)(object)val != (Object)null)
					{
						list.Add(((Component)val).gameObject);
					}
				}
			}
			GameObject result = null;
			float num = -1f;
			int num2 = 0;
			foreach (GameObject item in list)
			{
				Transform transform = item.transform;
				RectTransform val2 = (RectTransform)(object)((transform is RectTransform) ? transform : null);
				if ((Object)(object)val2 == (Object)null)
				{
					num2++;
					continue;
				}
				TMP_Text[] componentsInChildren2 = item.GetComponentsInChildren<TMP_Text>(true);
				if (componentsInChildren2.Length != 1)
				{
					num2++;
					continue;
				}
				if (!Stretched(componentsInChildren2[0].rectTransform))
				{
					num2++;
					continue;
				}
				if (item.GetComponentsInChildren<Button>(true).Length > 1)
				{
					num2++;
					continue;
				}
				if ((Object)(object)item.GetComponentInChildren<LayoutGroup>(true) != (Object)null)
				{
					num2++;
					continue;
				}
				Rect rect = val2.rect;
				float width = ((Rect)(ref rect)).width;
				rect = val2.rect;
				float height = ((Rect)(ref rect)).height;
				if (width < 40f || height < 12f || width > 900f || height > 220f)
				{
					num2++;
					continue;
				}
				float num3 = width * height;
				if (!(num3 <= num))
				{
					num = num3;
					result = item;
				}
			}
			if (num2 > 0)
			{
				Plugin.Log.LogInfo((object)("[NativeUI] " + num2 + " of " + list.Count + " candidates were containers, two-label controls, or the wrong shape for a button."));
			}
			return result;
		}

		private static bool Stretched(RectTransform rt)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: 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_0040: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)rt != (Object)null && rt.anchorMin.x < 0.01f && rt.anchorMin.y < 0.01f && rt.anchorMax.x > 0.99f)
			{
				return rt.anchorMax.y > 0.99f;
			}
			return false;
		}

		private static Transform OwnCanvas()
		{
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Expected O, but got Unknown
			//IL_0055: 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_00e7: 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_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: Expected O, but got Unknown
			if ((Object)(object)_ours != (Object)null)
			{
				return _ours.transform;
			}
			GameObject val = new GameObject("Fishwarden_Canvas", new Type[3]
			{
				typeof(Canvas),
				typeof(CanvasScaler),
				typeof(GraphicRaycaster)
			});
			Object.DontDestroyOnLoad((Object)val);
			Canvas component = val.GetComponent<Canvas>();
			component.renderMode = (RenderMode)0;
			component.sortingOrder = 30000;
			CanvasScaler component2 = val.GetComponent<CanvasScaler>();
			CanvasScaler val2 = (((Object)(object)_canvas != (Object)null) ? ((Component)_canvas).GetComponentInParent<CanvasScaler>() : null);
			if ((Object)(object)val2 != (Object)null)
			{
				component2.uiScaleMode = val2.uiScaleMode;
				component2.referenceResolution = val2.referenceResolution;
				component2.screenMatchMode = val2.screenMatchMode;
				component2.matchWidthOrHeight = val2.matchWidthOrHeight;
				component2.referencePixelsPerUnit = val2.referencePixelsPerUnit;
			}
			else
			{
				component2.uiScaleMode = (ScaleMode)1;
				component2.referenceResolution = new Vector2(1920f, 1080f);
				component2.matchWidthOrHeight = 0.5f;
			}
			_ours = val;
			return val.transform;
		}

		public static void DropCanvas()
		{
			if (!((Object)(object)_ours == (Object)null))
			{
				Object.Destroy((Object)(object)_ours);
				_ours = null;
			}
		}

		private static void Describe(GameObject go)
		{
			try
			{
				Plugin.Log.LogInfo((object)("[NativeUI] template structure: " + ((Object)go).name));
				Walk(go.transform, 0);
				GameObject val = SliderTemplate();
				if ((Object)(object)val == (Object)null)
				{
					Plugin.Log.LogInfo((object)"[NativeUI] no slider template yet - open the options screen once and reopen the console to see it.");
					return;
				}
				Plugin.Log.LogInfo((object)("[NativeUI] slider template: " + ((Object)val).name));
				Walk(val.transform, 0);
			}
			catch (Exception ex)
			{
				Plugin.Log.LogError((object)("[NativeUI] could not describe: " + ex));
			}
		}

		private static void Walk(Transform t, int depth)
		{
			//IL_0092: 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_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: 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_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_012a: 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_0150: Unknown result type (might be due to invalid IL or missing references)
			//IL_0155: Unknown result type (might be due to invalid IL or missing references)
			//IL_0176: 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)
			//IL_019c: 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_01c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e8: 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_020e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0213: Unknown result type (might be due to invalid IL or missing references)
			//IL_042d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0432: Unknown result type (might be due to invalid IL or missing references)
			//IL_044e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0453: Unknown result type (might be due to invalid IL or missing references)
			//IL_04cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_04d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_04f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_04f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0516: Unknown result type (might be due to invalid IL or missing references)
			//IL_051b: Unknown result type (might be due to invalid IL or missing references)
			//IL_053d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0542: 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_0569: Unknown result type (might be due to invalid IL or missing references)
			if (depth <= 8)
			{
				string text = new string(' ', depth * 2);
				RectTransform val = (RectTransform)(object)((t is RectTransform) ? t : null);
				string text2 = string.Join(", ", (from c in ((Component)t).GetComponents<Component>()
					where (Object)(object)c != (Object)null
					select ((object)c).GetType().Name).ToArray());
				object obj;
				if (!((Object)(object)val != (Object)null))
				{
					obj = "-";
				}
				else
				{
					string[] array = new string[21];
					Rect rect = val.rect;
					array[0] = ((Rect)(ref rect)).width.ToString("0");
					array[1] = "x";
					rect = val.rect;
					array[2] = ((Rect)(ref rect)).height.ToString("0");
					array[3] = " anchors ";
					array[4] = val.anchorMin.x.ToString("0.##");
					array[5] = ",";
					array[6] = val.anchorMin.y.ToString("0.##");
					array[7] = "-";
					array[8] = val.anchorMax.x.ToString("0.##");
					array[9] = ",";
					array[10] = val.anchorMax.y.ToString("0.##");
					array[11] = " pivot ";
					array[12] = val.pivot.x.ToString("0.##");
					array[13] = ",";
					array[14] = val.pivot.y.ToString("0.##");
					array[15] = " pos ";
					array[16] = val.anchoredPosition.x.ToString("0");
					array[17] = ",";
					array[18] = val.anchoredPosition.y.ToString("0");
					array[19] = " scale ";
					array[20] = ((Transform)val).localScale.x.ToString("0.##");
					obj = string.Concat(array);
				}
				string text3 = (string)obj;
				string text4 = "";
				HorizontalOrVerticalLayoutGroup component = ((Component)t).GetComponent<HorizontalOrVerticalLayoutGroup>();
				if ((Object)(object)component != (Object)null)
				{
					text4 = text4 + "  " + ((component is VerticalLayoutGroup) ? "VLG" : "HLG") + " ctrl " + (component.childControlWidth ? "W" : "-") + (component.childControlHeight ? "H" : "-") + " expand " + (component.childForceExpandWidth ? "W" : "-") + (component.childForceExpandHeight ? "H" : "-");
				}
				LayoutElement[] components = ((Component)t).GetComponents<LayoutElement>();
				foreach (LayoutElement val2 in components)
				{
					text4 = text4 + "  LE pref " + val2.preferredWidth.ToString("0.#") + "/" + val2.preferredHeight.ToString("0.#") + " min " + val2.minWidth.ToString("0.#") + "/" + val2.minHeight.ToString("0.#") + " flex " + val2.flexibleWidth.ToString("0.##") + "/" + val2.flexibleHeight.ToString("0.##") + (val2.ignoreLayout ? " IGNORED" : "");
				}
				ContentSizeFitter component2 = ((Component)t).GetComponent<ContentSizeFitter>();
				if ((Object)(object)component2 != (Object)null)
				{
					text4 = text4 + "  CSF h:" + ((object)component2.horizontalFit/*cast due to .constrained prefix*/).ToString() + " v:" + ((object)component2.verticalFit/*cast due to .constrained prefix*/).ToString();
				}
				TMP_Text component3 = ((Component)t).GetComponent<TMP_Text>();
				if ((Object)(object)component3 != (Object)null)
				{
					text4 = text4 + "  font " + component3.fontSize.ToString("0.#") + (component3.enableAutoSizing ? " auto" : "") + " " + ((object)component3.alignment/*cast due to .constrained prefix*/).ToString() + " margin " + component3.margin.x.ToString("0") + "," + component3.margin.y.ToString("0") + "," + component3.margin.z.ToString("0") + "," + component3.margin.w.ToString("0") + " \"" + (component3.text ?? "").Replace("\n", "\\n") + "\"";
				}
				Plugin.Log.LogInfo((object)("[NativeUI]   " + text + ((Object)t).name + "  [" + text3 + "]  " + text2 + text4));
				for (int num2 = 0; num2 < t.childCount; num2++)
				{
					Walk(t.GetChild(num2), depth + 1);
				}
			}
		}

		private static Transform ActiveCanvas()
		{
			try
			{
				return (from c in Object.FindObjectsByType<Canvas>((FindObjectsInactive)0)
					where (Object)(object)c != (Object)null && ((Behaviour)c).isActiveAndEnabled && ((Component)c).gameObject.activeInHierarchy
					where (int)c.renderMode != 2
					orderby c.sortingOrder descending
					select ((Component)c).transform).FirstOrDefault();
			}
			catch
			{
				return null;
			}
		}

		public static GameObject Sheet(string name, float widthFrac, float heightFrac)
		{
			//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_004b: 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_006f: 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)
			GameObject val = Panel(name, Vector2.zero, Vector2.zero);
			if ((Object)(object)val == (Object)null)
			{
				return null;
			}
			RectTransform component = val.GetComponent<RectTransform>();
			float num = Mathf.Clamp01(widthFrac) * 0.5f;
			float num2 = Mathf.Clamp01(heightFrac) * 0.5f;
			component.anchorMin = new Vector2(0.5f - num, 0.5f - num2);
			component.anchorMax = new Vector2(0.5f + num, 0.5f + num2);
			component.offsetMin = Vector2.zero;
			component.offsetMax = Vector2.zero;
			return val;
		}

		public static GameObject Panel(string name, Vector2 size, Vector2 anchoredPos)
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Expected O, but got Unknown
			//IL_0043: 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_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: 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_0100: 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_014c: Unknown result type (might be due to invalid IL or missing references)
			//IL_015e: 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_01a4: Unknown result type (might be due to invalid IL or missing references)
			if (!Prepare())
			{
				return null;
			}
			GameObject val = new GameObject(name, new Type[2]
			{
				typeof(RectTransform),
				typeof(Image)
			});
			RectTransform component = val.GetComponent<RectTransform>();
			((Transform)component).SetParent(OwnCanvas(), false);
			component.sizeDelta = size;
			component.anchoredPosition = anchoredPos;
			((Transform)component).SetAsLastSibling();
			Image component2 = val.GetComponent<Image>();
			component2.sprite = null;
			Material val2 = (((Graphic)component2).material = BorrowBlur());
			((Graphic)component2).color = (Color)(((Object)(object)val2 != (Object)null) ? Theme.GlassBase : new Color(0f, 0f, 0f, 0f));
			GameObject val4 = new GameObject("Tint", new Type[2]
			{
				typeof(RectTransform),
				typeof(Image)
			});
			val4.transform.SetParent(val.transform, false);
			Stretch(val4.GetComponent<RectTransform>(), 0f, 0f);
			val4.AddComponent<LayoutElement>().ignoreLayout = true;
			Image component3 = val4.GetComponent<Image>();
			((Graphic)component3).color = Theme.Glass;
			((Graphic)component3).raycastTarget = false;
			Image val5 = BorrowPanelSprite();
			if ((Object)(object)val5 != (Object)null)
			{
				GameObject val6 = new GameObject("Frame", new Type[2]
				{
					typeof(RectTransform),
					typeof(Image)
				});
				val6.transform.SetParent(val.transform, false);
				Stretch(val6.GetComponent<RectTransform>(), 0f, 0f);
				val6.AddComponent<LayoutElement>().ignoreLayout = true;
				Image component4 = val6.GetComponent<Image>();
				component4.sprite = val5.sprite;
				component4.type = (Type)1;
				component4.pixelsPerUnitMultiplier = 1f;
				((Graphic)component4).color = ((Graphic)val5).color;
				((Graphic)component4).raycastTarget = false;
			}
			return val;
		}

		public static GameObject Button(Transform parent, string label, System.Action onClick, Vector2 size, Vector2 pos, string hint = null)
		{
			//IL_0060: 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_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: 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_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Expected O, but got Unknown
			if (!Prepare())
			{
				return null;
			}
			GameObject val = Object.Instantiate<GameObject>(_buttonTemplate, parent, false);
			((Object)val).name = "Gambit_" + label;
			val.SetActive(true);
			Sterilise(val);
			Steady(val);
			RectTransform component = val.GetComponent<RectTransform>();
			if ((Object)(object)component != (Object)null)
			{
				component.anchoredPosition = pos;
			}
			LayoutElement val2 = Sizing(val, (size.y > 0f) ? size.y : 40f);
			val2.minHeight = val2.preferredHeight;
			if (size.x > 0f)
			{
				val2.preferredWidth = size.x;
			}
			FitInside(val, val2.preferredHeight);
			Back(val, Theme.Row);
			SetLabel(val, label);
			Button component2 = val.GetComponent<Button>();
			if ((Object)(object)component2 != (Object)null)
			{
				((UnityEventBase)component2.onClick).RemoveAllListeners();
				((UnityEvent)component2.onClick).AddListener((UnityAction)delegate
				{
					Safely(onClick);
				});
				((Selectable)component2).interactable = true;
			}
			if (!string.IsNullOrEmpty(hint))
			{
				Explain(val, hint);
			}
			return val;
		}

		public static void Explain(GameObject go, string hint)
		{
			//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_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Expected O, but got Unknown
			if ((Object)(object)go == (Object)null || string.IsNullOrEmpty(hint))
			{
				return;
			}
			try
			{
				EventTrigger obj = go.AddComponent<EventTrigger>();
				Entry val = new Entry
				{
					eventID = (EventTriggerType)0
				};
				((UnityEvent<BaseEventData>)(object)val.callback).AddListener((UnityAction<BaseEventData>)delegate
				{
					if (OnHover != null)
					{
						Safely(delegate
						{
							OnHover(hint);
						});
					}
				});
				obj.triggers.Add(val);
			}
			catch
			{
			}
		}

		private static void Steady(GameObject go)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: 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_0066: Invalid comparison between Unknown and I4
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)go == (Object)null)
			{
				return;
			}
			go.transform.localScale = Vector3.one;
			go.transform.localRotation = Quaternion.identity;
			Animator[] componentsInChildren = go.GetComponentsInChildren<Animator>(true);
			foreach (Animator obj in componentsInChildren)
			{
				((Behaviour)obj).enabled = false;
				Object.Destroy((Object)(object)obj);
			}
			Selectable[] componentsInChildren2 = go.GetComponentsInChildren<Selectable>(true);
			foreach (Selectable val in componentsInChildren2)
			{
				if ((int)val.transition == 3)
				{
					val.transition = (Transition)1;
				}
			}
			Transform[] componentsInChildren3 = go.GetComponentsInChildren<Transform>(true);
			for (int i = 0; i < componentsInChildren3.Length; i++)
			{
				componentsInChildren3[i].localScale = Vector3.one;
			}
			CanvasGroup[] componentsInChildren4 = go.GetComponentsInChildren<CanvasGroup>(true);
			foreach (CanvasGroup obj2 in componentsInChildren4)
			{
				obj2.alpha = 1f;
				obj2.interactable = true;
				obj2.blocksRaycasts = true;
				obj2.ignoreParentGroups = false;
			}
		}

		private static void FitInside(GameObject go, float height)
		{
			//IL_003a: 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_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: 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_0143: Unknown result type (might be due to invalid IL or missing references)
			//IL_014f: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)go == (Object)null)
			{
				return;
			}
			TMP_Text[] componentsInChildren = go.GetComponentsInChildren<TMP_Text>(true);
			foreach (TMP_Text val in componentsInChildren)
			{
				if (!((Object)(object)val == (Object)null))
				{
					RectTransform rectTransform = val.rectTransform;
					rectTransform.pivot = new Vector2(0.5f, 0.5f);
					rectTransform.anchorMin = Vector2.zero;
					rectTransform.anchorMax = Vector2.one;
					rectTransform.offsetMin = new Vector2(10f, 0f);
					rectTransform.offsetMax = new Vector2(-10f, 0f);
					((Transform)rectTransform).localScale = Vector3.one;
					val.alignment = (TextAlignmentOptions)513;
					val.textWrappingMode = (TextWrappingModes)0;
					val.overflowMode = (TextOverflowModes)1;
					val.enableAutoSizing = true;
					val.fontSizeMin = 9f;
					val.fontSizeMax = Mathf.Clamp(height * 0.52f, 11f, 34f);
				}
			}
			Image[] componentsInChildren2 = go.GetComponentsInChildren<Image>(true);
			foreach (Image val2 in componentsInChildren2)
			{
				if (!((Object)(object)val2 == (Object)null) && !((Object)(object)((Component)val2).gameObject == (Object)(object)go))
				{
					RectTransform rectTransform2 = ((Graphic)val2).rectTransform;
					if (!((Object)(object)((Transform)rectTransform2).parent != (Object)(object)go.transform))
					{
						rectTransform2.anchorMin = Vector2.zero;
						rectTransform2.anchorMax = Vector2.one;
						rectTransform2.offsetMin = Vector2.zero;
						rectTransform2.offsetMax = Vector2.zero;
					}
				}
			}
		}

		public static void SetLabel(GameObject button, string text)
		{
			if (!((Object)(object)button == (Object)null))
			{
				TMP_Text[] componentsInChildren = button.GetComponentsInChildren<TMP_Text>(true);
				for (int i = 0; i < componentsInChildren.Length; i++)
				{
					Say(componentsInChildren[i], text);
				}
			}
		}

		public static void Say(TMP_Text t, string text)
		{
			if (!((Object)(object)t == (Object)null))
			{
				t.text = text;
				_pinned[t] = text;
			}
		}

		public static void HoldLabels()
		{
			if (_pinned.Count == 0)
			{
				return;
			}
			List<TMP_Text> list = null;
			foreach (KeyValuePair<TMP_Text, string> item in _pinned)
			{
				TMP_Text key = item.Key;
				if ((Object)(object)key == (Object)null)
				{
					(list ?? (list = new List<TMP_Text>())).Add(key);
				}
				else if (key.text != item.Value)
				{
					key.text = item.Value;
				}
			}
			if (list == null)
			{
				return;
			}
			foreach (TMP_Text item2 in list)
			{
				_pinned.Remove(item2);
			}
		}

		public static void ForgetLabels()
		{
			_pinned.Clear();
		}

		private static void Sterilise(GameObject go)
		{
			if ((Object)(object)go == (Object)null)
			{
				return;
			}
			MonoBehaviour[] componentsInChildren = go.GetComponentsInChildren<MonoBehaviour>(true);
			foreach (MonoBehaviour val in componentsInChildren)
			{
				if (!((Object)(object)val == (Object)null) && !(val is Graphic) && !(val is Selectable) && !(val is LayoutElement) && !(val is LayoutGroup) && !(val is ContentSizeFitter) && !(val is ScrollRect) && !(val is Mask) && !(val is RectMask2D))
				{
					try
					{
						Object.DestroyImmediate((Object)(object)val);
					}
					catch
					{
					}
				}
			}
		}

		public static TMP_Text Label(Transform parent, string text, Vector2 pos, float size = 0f)
		{
			//IL_0075: 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_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: 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_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: Unknown result type (might be due to invalid IL or missing references)
			if (!Prepare())
			{
				return null;
			}
			TMP_Text componentInChildren = _buttonTemplate.GetComponentInChildren<TMP_Text>(true);
			if ((Object)(object)componentInChildren == (Object)null)
			{
				return null;
			}
			GameObject obj = Object.Instantiate<GameObject>(((Component)componentInChildren).gameObject, parent, false);
			((Object)obj).name = "Gambit_Label";
			obj.SetActive(true);
			Sterilise(obj);
			Steady(obj);
			TMP_Text component = obj.GetComponent<TMP_Text>();
			component.text = text;
			_pinned[component] = text;
			RectTransform component2 = obj.GetComponent<RectTransform>();
			component2.pivot = new Vector2(0.5f, 0.5f);
			component2.anchorMin = new Vector2(0f, 0f);
			component2.anchorMax = new Vector2(1f, 1f);
			component2.offsetMin = Vector2.zero;
			component2.offsetMax = Vector2.zero;
			((Transform)component2).localScale = Vector3.one;
			component2.anchoredPosition = pos;
			((Graphic)component).raycastTarget = false;
			component.enableAutoSizing = false;
			component.fontSize = ((size > 0f) ? size : 14f);
			component.alignment = (TextAlignmentOptions)257;
			component.textWrappingMode = (TextWrappingModes)1;
			component.overflowMode = (TextOverflowModes)3;
			component.margin = Vector4.zero;
			return component;
		}

		public static Transform Scroll(Transform parent, float width)
		{
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Expected O, but got Unknown
			//IL_006d: 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_00e5: 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_0109: 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_0133: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: 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_0168: Unknown result type (might be due to invalid IL or missing references)
			//IL_0172: Unknown result type (might be due to invalid IL or missing references)
			//IL_019e: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("Scroll", new Type[4]
			{
				typeof(RectTransform),
				typeof(ScrollRect),
				typeof(RectMask2D),
				typeof(LayoutElement)
			});
			val.transform.SetParent(parent, false);
			Image obj = val.AddComponent<Image>();
			((Graphic)obj).color = new Color(0f, 0f, 0f, 0f);
			((Graphic)obj).raycastTarget = true;
			LayoutElement component = val.GetComponent<LayoutElement>();
			component.preferredWidth = width;
			component.flexibleHeight = 1f;
			component.flexibleWidth = ((width <= 0f) ? 1f : 0f);
			GameObject val2 = new GameObject("Content", new Type[3]
			{
				typeof(RectTransform),
				typeof(VerticalLayoutGroup),
				typeof(ContentSizeFitter)
			});
			val2.transform.SetParent(val.transform, false);
			RectTransform component2 = val2.GetComponent<RectTransform>();
			component2.anchorMin = new Vector2(0f, 1f);
			component2.anchorMax = new Vector2(1f, 1f);
			component2.pivot = new Vector2(0.5f, 1f);
			component2.anchoredPosition = Vector2.zero;
			component2.sizeDelta = new Vector2(-12f, 0f);
			component2.anchoredPosition = new Vector2(-6f, 0f);
			VerticalLayoutGroup component3 = val2.GetComponent<VerticalLayoutGroup>();
			((HorizontalOrVerticalLayoutGroup)component3).spacing = 4f;
			((HorizontalOrVerticalLayoutGroup)component3).childControlWidth = true;
			((HorizontalOrVerticalLayoutGroup)component3).childControlHeight = true;
			((HorizontalOrVerticalLayoutGroup)component3).childForceExpandHeight = false;
			((HorizontalOrVerticalLayoutGroup)component3).childForceExpandWidth = true;
			val2.GetComponent<ContentSizeFitter>().verticalFit = (FitMode)2;
			ScrollRect component4 = val.GetComponent<ScrollRect>();
			component4.content = component2;
			component4.viewport = val.GetComponent<RectTransform>();
			component4.horizontal = false;
			component4.vertical = true;
			component4.movementType = (MovementType)2;
			component4.scrollSensitivity = 0f;
			component4.inertia = false;
			val.AddComponent<NativeScroll>().Rect = component4;
			component4.verticalScrollbar = Bar(val.transform);
			component4.verticalScrollbarVisibility = (ScrollbarVisibility)1;
			return val2.transform;
		}

		public static TMP_InputField Field(Transform parent, string placeholder, string value, Action<string> onChange, float height = 0f)
		{
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_012c: Unknown result type (might be due to invalid IL or missing references)
			if (!Prepare())
			{
				return null;
			}
			GameObject val = FieldTemplate();
			if ((Object)(object)val == (Object)null)
			{
				return null;
			}
			GameObject val2 = Object.Instantiate<GameObject>(val, parent, false);
			((Object)val2).name = "Gambit_Search";
			val2.SetActive(true);
			Sterilise(val2);
			Steady(val2);
			Back(val2, Theme.Row);
			Sizing(val2, (height > 0f) ? height : 40f);
			TMP_InputField component = val2.GetComponent<TMP_InputField>();
			if ((Object)(object)component == (Object)null)
			{
				Object.Destroy((Object)(object)val2);
				return null;
			}
			((UnityEventBase)component.onValueChanged).RemoveAllListeners();
			((UnityEventBase)component.onEndEdit).RemoveAllListeners();
			((UnityEventBase)component.onSubmit).RemoveAllListeners();
			component.characterLimit = 32;
			component.lineType = (LineType)0;
			((Selectable)component).interactable = true;
			component.text = value ?? "";
			if ((Object)(object)component.textComponent != (Object)null)
			{
				((Graphic)component.textComponent).color = Theme.Ink;
				component.textComponent.enableAutoSizing = false;
				component.textComponent.fontSize = 16f;
			}
			Graphic placeholder2 = component.placeholder;
			TMP_Text val3 = (TMP_Text)(object)((placeholder2 is TMP_Text) ? placeholder2 : null);
			if ((Object)(object)val3 != (Object)null)
			{
				val3.text = placeholder;
				((Graphic)val3).color = Theme.Faint;
				val3.enableAutoSizing = false;
				val3.fontSize = 16f;
			}
			((UnityEvent<string>)(object)component.onValueChanged).AddListener((UnityAction<string>)delegate(string s)
			{
				Safely(delegate
				{
					onChange(s);
				});
			});
			return component;
		}

		private static GameObject FieldTemplate()
		{
			if ((Object)(object)_fieldTemplate != (Object)null)
			{
				return _fieldTemplate;
			}
			try
			{
				_fieldTemplate = (from f in Resources.FindObjectsOfTypeAll<TMP_InputField>().Where(delegate(TMP_InputField f)
					{
						//IL_000f: 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)f != (Object)null)
						{
							Scene scene = ((Component)f).gameObject.scene;
							return ((Scene)(ref scene)).IsValid();
						}
						return false;
					})
					where (Object)(object)f.textComponent != (Object)null
					select ((Component)f).gameObject).FirstOrDefault();
				if ((Object)(object)_fieldTemplate == (Object)null)
				{
					Plugin.Log.LogInfo((object)"[NativeUI] no text box to copy - the spawn list will stay paged.");
				}
				else
				{
					Plugin.Log.LogInfo((object)("[NativeUI] search boxes are copied from '" + ((Object)_fieldTemplate).name + "'."));
				}
			}
			catch
			{
			}
			return _fieldTemplate;
		}

		private static Scrollbar Bar(Transform parent)
		{
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Expected O, but got Unknown
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: 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_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Expected O, but got Unknown
			//IL_0137: Unknown result type (might be due to invalid IL or missing references)
			//IL_013d: Expected O, but got Unknown
			//IL_0169: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("Bar", new Type[3]
			{
				typeof(RectTransform),
				typeof(Image),
				typeof(Scrollbar)
			});
			val.transform.SetParent(parent, false);
			RectTransform component = val.GetComponent<RectTransform>();
			component.anchorMin = new Vector2(1f, 0f);
			component.anchorMax = new Vector2(1f, 1f);
			component.pivot = new Vector2(1f, 0.5f);
			component.sizeDelta = new Vector2(12f, 0f);
			component.anchoredPosition = Vector2.zero;
			((Graphic)val.GetComponent<Image>()).color = new Color(1f, 1f, 1f, 0.07f);
			GameObject val2 = new GameObject("Area", new Type[1] { typeof(RectTransform) });
			val2.transform.SetParent(val.transform, false);
			Stretch(val2.GetComponent<RectTransform>(), 0f, 6f);
			GameObject val3 = new GameObject("Handle", new Type[2]
			{
				typeof(RectTransform),
				typeof(Image)
			});
			val3.transform.SetParent(val2.transform, false);
			((Graphic)val3.GetComponent<Image>()).color = new Color(1f, 1f, 1f, 0.38f);
			Scrollbar component2 = val.GetComponent<Scrollbar>();
			component2.direction = (Direction)2;
			component2.handleRect = val3.GetComponent<RectTransform>();
			((Selectable)component2).targetGraphic = (Graphic)(object)val3.GetComponent<Image>();
			return component2;
		}

		public static GameObject Toggle(Transform parent, string label, bool on, System.Action onClick, float height = 0f)
		{
			//IL_001e: 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)
			GameObject obj = Button(parent, (on ? "✓  " : "     ") + label, onClick, new Vector2(0f, height), Vector2.zero);
			Mark(obj, on);
			return obj;
		}

		public static Dial Slider(Transform parent, string label, float value, float min, float max, Action<float> onChange, string format = "0.0", bool whole = false)
		{
			//IL_0033: 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_0045: 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_0075: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("Dial", new Type[2]
			{
				typeof(RectTransform),
				typeof(VerticalLayoutGroup)
			});
			val.transform.SetParent(parent, false);
			VerticalLayoutGroup component = val.GetComponent<VerticalLayoutGroup>();
			((HorizontalOrVerticalLayoutGroup)component).spacing = 1f;
			((HorizontalOrVerticalLayoutGroup)component).childControlWidth = true;
			((HorizontalOrVerticalLayoutGroup)component).childControlHeight = true;
			((HorizontalOrVerticalLayoutGroup)component).childForceExpandHeight = false;
			TMP_Text val2 = Label(val.transform, "", Vector2.zero);
			if ((Object)(object)val2 != (Object)null)
			{
				Sizing(((Component)val2).gameObject, 20f);
				val2.alignment = (TextAlignmentOptions)513;
			}
			Slider val3 = MakeBar(val.transform);
			if ((Object)(object)val3 == (Object)null)
			{
				return new Dial
				{
					Caption = val2,
					Format = format,
					Label = label,
					Value = value
				};
			}
			val3.minValue = min;
			val3.maxValue = max;
			val3.wholeNumbers = whole;
			val3.SetValueWithoutNotify(value);
			Dial dial = new Dial
			{
				Caption = val2,
				Bar = val3,
				Format = format,
				Label = label,
				Value = value
			};
			((UnityEvent<float>)(object)val3.onValueChanged).AddListener((UnityAction<float>)delegate(float x)
			{
				dial.Value = x;
				dial.Sync();
				Safely(delegate
				{
					onChange(x);
				});
			});
			dial.Sync();
			return dial;
		}

		private static Slider MakeBar(Transform parent)
		{
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = SliderTemplate();
			if ((Object)(object)val != (Object)null)
			{
				GameObject val2 = Object.Instantiate<GameObject>(val, parent, false);
				((Object)val2).name = "Gambit_Bar";
				val2.SetActive(true);
				Sterilise(val2);
				Steady(val2);
				Slider component = val2.GetComponent<Slider>();
				if ((Object)(object)component != (Object)null)
				{
					((UnityEventBase)component.onValueChanged).RemoveAllListeners();
					((Selectable)component).interactable = true;
				}
				Sizing(val2, 20f);
				if ((Object)(object)val2.GetComponent<Image>() == (Object)null)
				{
					Image obj = val2.AddComponent<Image>();
					((Graphic)obj).color = new Color(0f, 0f, 0f, 0f);
					((Graphic)obj).raycastTarget = true;
				}
				return component;
			}
			return PlainBar(parent);
		}

		private static Slider PlainBar(Transform parent)
		{
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Expected O, but got Unknown
			//IL_006f: 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_0097: Expected O, but got Unknown
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Expected O, but got Unknown
			//IL_0101: 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_0129: Expected O, but got Unknown
			//IL_0175: Unknown result type (might be due to invalid IL or missing references)
			//IL_017c: Expected O, but got Unknown
			//IL_0196: 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)
			GameObject val = new GameObject("Gambit_Bar", new Type[3]
			{
				typeof(RectTransform),
				typeof(Slider),
				typeof(LayoutElement)
			});
			val.transform.SetParent(parent, false);
			val.GetComponent<LayoutElement>().preferredHeight = 20f;
			((Graphic)val.AddComponent<Image>()).color = new Color(1f, 1f, 1f, 0.12f);
			GameObject val2 = new GameObject("FillArea", new Type[1] { typeof(RectTransform) });
			val2.transform.SetParent(val.transform, false);
			Stretch(val2.GetComponent<RectTransform>(), 0f, 6f);
			GameObject val3 = new GameObject("Fill", new Type[2]
			{
				typeof(RectTransform),
				typeof(Image)
			});
			val3.transform.SetParent(val2.transform, false);
			((Graphic)val3.GetComponent<Image>()).color = Theme.Accent;
			GameObject val4 = new GameObject("HandleArea", new Type[1] { typeof(RectTransform) });
			val4.transform.SetParent(val.transform, false);
			Stretch(val4.GetComponent<RectTransform>(), 0f, 0f);
			GameObject val5 = new GameObject("Handle", new Type[2]
			{
				typeof(RectTransform),
				typeof(Image)
			});
			val5.transform.SetParent(val4.transform, false);
			((Graphic)val5.GetComponent<Image>()).color = Theme.Ink;
			val5.GetComponent<RectTransform>().sizeDelta = new Vector2(14f, 0f);
			Slider component = val.GetComponent<Slider>();
			component.fillRect = val3.GetComponent<RectTransform>();
			component.handleRect = val5.GetComponent<RectTransform>();
			((Selectable)component).targetGraphic = (Graphic)(object)val5.GetComponent<Image>();
			component.direction = (Direction)0;
			return component;
		}

		private static void Stretch(RectTransform rt, float padX, float padY)
		{
			//IL_0001: 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_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)
			rt.anchorMin = Vector2.zero;
			rt.anchorMax = Vector2.one;
			rt.offsetMin = new Vector2(padX, padY);
			rt.offsetMax = new Vector2(0f - padX, 0f - padY);
		}

		private static GameObject SliderTemplate()
		{
			if ((Object)(object)_sliderTemplate != (Object)null)
			{
				return _sliderTemplate;
			}
			try
			{
				_sliderTemplate = (from s in Resources.FindObjectsOfTypeAll<Slider>().Where(delegate(Slider s)
					{
						//IL_000f: 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)s != (Object)null)
						{
							Scene scene = ((Component)s).gameObject.scene;
							return ((Scene)(ref scene)).IsValid();
						}
						return false;
					})
					where (Object)(object)s.fillRect != (Object)null && (Object)(object)s.handleRect != (Object)null
					select ((Component)s).gameObject).FirstOrDefault();
			}
			catch
			{
			}
			return _sliderTemplate;
		}

		public static Transform Group(Transform parent, Color edge)
		{
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Expected O, but got Unknown
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Expected O, but got Unknown
			//IL_00ca: 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_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: 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)
			//IL_011b: 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_0141: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("Group", new Type[3]
			{
				typeof(RectTransform),
				typeof(VerticalLayoutGroup),
				typeof(LayoutElement)
			});
			val.transform.SetParent(parent, false);
			VerticalLayoutGroup component = val.GetComponent<VerticalLayoutGroup>();
			((LayoutGroup)component).padding = new RectOffset(10, 10, 8, 10);
			((HorizontalOrVerticalLayoutGroup)component).spacing = 4f;
			((HorizontalOrVerticalLayoutGroup)component).childControlWidth = true;
			((HorizontalOrVerticalLayoutGroup)component).childControlHeight = true;
			((HorizontalOrVerticalLayoutGroup)component).childForceExpandHeight = false;
			((HorizontalOrVerticalLayoutGroup)component).childForceExpandWidth = true;
			val.GetComponent<LayoutElement>().flexibleHeight = 0f;
			Sprite val2 = OutlineSprite();
			if ((Object)(object)val2 != (Object)null)
			{
				GameObject val3 = new GameObject("Edge", new Type[2]
				{
					typeof(RectTransform),
					typeof(Image)
				});
				val3.transform.SetParent(val.transform, false);
				val3.transform.SetAsFirstSibling();
				Stretch(val3.GetComponent<RectTransform>(), 0f, 0f);
				val3.AddComponent<LayoutElement>().ignoreLayout = true;
				Image component2 = val3.GetComponent<Image>();
				component2.sprite = val2;
				component2.type = (Type)((val2.border != Vector4.zero) ? 1 : 0);
				component2.pixelsPerUnitMultiplier = 1f;
				((Graphic)component2).color = edge;
				((Graphic)component2).raycastTarget = false;
			}
			return val.transform;
		}

		public static void Edge(GameObject go, Color c)
		{
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)go == (Object)null)
			{
				return;
			}
			Image[] componentsInChildren = go.GetComponentsInChildren<Image>(true);
			foreach (Image val in componentsInChildren)
			{
				if (!((Object)(object)val == (Object)null) && !((Object)(object)((Component)val).gameObject == (Object)(object)go) && !((Object)(object)val.sprite == (Object)null))
				{
					((Graphic)val).color = c;
					break;
				}
			}
		}

		private static Sprite OutlineSprite()
		{
			if (!Prepare())
			{
				return null;
			}
			Image[] componentsInChildren = _buttonTemplate.GetComponentsInChildren<Image>(true);
			foreach (Image val in componentsInChildren)
			{
				if (!((Object)(object)val == (Object)null) && !((Object)(object)val.sprite == (Object)null) && !((Object)(object)((Component)val).gameObject == (Object)(object)_buttonTemplate))
				{
					return val.sprite;
				}
			}
			return null;
		}

		public static TMP_Text Header(Transform parent, string text)
		{
			//IL_0002: 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)
			TMP_Text val = Label(parent, text, Vector2.zero);
			if ((Object)(object)val == (Object)null)
			{
				return null;
			}
			((Graphic)val).color = Theme.Accent;
			val.alignment = (TextAlignmentOptions)513;
			Sizing(((Component)val).gameObject, 24f);
			return val;
		}

		public static LayoutElement Sizing(GameObject go, float height)
		{
			if ((Object)(object)go == (Object)null)
			{
				return null;
			}
			LayoutElement[] components = go.GetComponents<LayoutElement>();
			LayoutElement val = ((components.Length != 0) ? components[0] : go.AddComponent<LayoutElement>());
			for (int i = 1; i < components.Length; i++)
			{
				try
				{
					Object.DestroyImmediate((Object)(object)components[i]);
				}
				catch
				{
				}
			}
			val.ignoreLayout = false;
			val.minWidth = -1f;
			val.preferredWidth = -1f;
			val.flexibleWidth = 1f;
			val.minHeight = 0f;
			val.preferredHeight = height;
			val.flexibleHeight = 0f;
			return val;
		}

		public static void Back(GameObject go, Color fill)
		{
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)go == (Object)null)
			{
				return;
			}
			Image component = go.GetComponent<Image>();
			if (!((Object)(object)component == (Object)null))
			{
				if ((Object)(object)((Graphic)component).material != (Object)null && (Object)(object)((Graphic)component).material != (Object)(object)Graphic.defaultGraphicMaterial)
				{
					((Graphic)component).material = null;
				}
				((Graphic)component).color = fill;
			}
		}

		public static void Mark(GameObject go, bool on)
		{
			//IL_0015: 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_002a: 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)
			if (!((Object)(object)go == (Object)null))
			{
				Back(go, on ? Theme.RowOn : Theme.Row);
				Paint(go, on ? Theme.Ink : Theme.Muted);
			}
		}

		public static void Paint(GameObject go, Color c)
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)go == (Object)null))
			{
				TMP_Text componentInChildren = go.GetComponentInChildren<TMP_Text>(true);
				if ((Object)(object)componentInChildren != (Object)null)
				{
					((Graphic)componentInChildren).color = c;
				}
			}
		}

		private static Material BorrowBlur()
		{
			//IL_0153: Unknown result type (might be due to invalid IL or missing references)
			//IL_015d: Expected O, but got Unknown
			if ((Object)(object)_glass != (Object)null)
			{
				return _glass;
			}
			try
			{
				List<Image> source = (from i in Resources.FindObjectsOfTypeAll<Image>().Where(delegate(Image i)
					{
						//IL_000f: 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)i != (Object)null)
						{
							Scene scene = ((Component)i).gameObject.scene;
							return ((Scene)(ref scene)).IsValid();
						}
						return false;
					})
					where (Object)(object)((Graphic)i).material != (Object)null && (Object)(object)((Graphic)i).material != (Object)(object)Graphic.defaultGraphicMaterial
					where Area(i) > 40000f
					select i).ToList();
				string pin = ((Plugin.Backdrop != null) ? Plugin.Backdrop.Value : null);
				if (string.IsNullOrWhiteSpace(pin))
				{
					return null;
				}
				Image val = (string.IsNullOrEmpty(pin) ? null : ((IEnumerable<Image>)source).FirstOrDefault((Func<Image, bool>)((Image i) => ((Object)((Graphic)i).material).name.IndexOf(pin, StringComparison.OrdinalIgnoreCase) >= 0)));
				if ((Object)(object)val == (Object)null && !string.IsNullOrEmpty(pin))
				{
					Plugin.Log.LogInfo((object)("[NativeUI] no backdrop called '" + pin + "' in this scene yet - plain sheet for now, frosted once there is one. NOT substituting a different material."));
					return null;
				}
				if ((Object)(object)val == (Object)null)
				{
					return null;
				}
				if ((Object)(object)val == (Object)null)
				{
					Plugin.Log.LogInfo((object)"[NativeUI] no frosted backdrop to borrow - the sheet will be flat.");
					return null;
				}
				_glass = new Material(((Graphic)val).material);
				((Object)_glass).name = ((Object)((Graphic)val).material).name + " (Gambit copy)";
				Plugin.Log.LogInfo((object)("[NativeUI] the sheet is borrowing '" + ((Object)((Graphic)val).material).name + "' from '" + ((Object)val).name + "' (copied, so the game cannot drive it)."));
				return _glass;
			}
			catch
			{
				return null;
			}
		}

		private static Image BorrowPanelSprite()
		{
			try
			{
				return (from i in ((Component)_canvas).GetComponentsInChildren<Image>(true)
					where (Object)(object)i != (Object)null && (Object)(object)i.sprite != (Object)null
					where (Object)(object)((Graphic)i).material == (Object)null || (Object)(object)((Graphic)i).material == (Object)(object)Graphic.defaultGraphicMaterial
					where i.sprite.border != Vector4.zero
					where Area(i) > 20000f
					orderby Area(i)
					select i).FirstOrDefault();
			}
			catch
			{
				return null;
			}
		}

		private static float Area(Image i)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			Rect rect = ((Graphic)i).rectTransform.rect;
			return Mathf.Abs(((Rect)(ref rect)).width * ((Rect)(ref rect)).height);
		}

		private static void Safely(System.Action a)
		{
			try
			{
				a();
			}
			catch (Exception ex)
			{
				Plugin.Log.LogError((object)("[NativeUI] click failed: " + ex));
			}
		}

		public static bool InputWorks()
		{
			try
			{
				return (Object)(object)EventSystem.current != (Object)null;
			}
			catch
			{
				return false;
			}
		}

		public static void Destroy()
		{
			if (!((Object)(object)_root == (Object)null))
			{
				Object.Destroy((Object)(object)_root);
				_root = null;
			}
		}
	}
	internal static class Overlay
	{
		private const int Pad = 12;

		private const int Row = 19;

		private const int HelpWidth = 430;

		public static bool ShowStatus = true;

		public static bool ShowHelp = true;

		private static GUIStyle _left;

		private static GUIStyle _right;

		private static Font _styleFont;

		private static float _pulse;

		private static Color Head => Theme.Accent;

		private static Color Bad => Theme.Bad;

		private static Color Warn => Theme.Warn;

		private static Color Good => Theme.Good;

		private static Color Dim => Theme.Faint;

		private static Color Urgent => Theme.Urgent;

		public static void Draw()
		{
			//IL_0032: 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_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Expected O, but got Unknown
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: 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_006c: Expected O, but got Unknown
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			if (NativeConsole.IsOpen)
			{
				return;
			}
			Font font = NativeLook.Font;
			if (_left == null || (Object)(object)_styleFont != (Object)(object)font)
			{
				_styleFont = font;
				_left = new GUIStyle(GUI.skin.label)
				{
					alignment = (TextAnchor)0,
					richText = false
				};
				_right = new GUIStyle(GUI.skin.label)
				{
					alignment = (TextAnchor)2,
					richText = false
				};
				if ((Object)(object)font != (Object)null)
				{
					_left.font = font;
					_right.font = font;
				}
			}
			_pulse = Mathf.PingPong(Time.realtimeSinceStartup * 1.6f, 1f);
			if (ShowStatus)
			{
				DrawStatus();
			}
			if (ShowHelp)
			{
				DrawHelp();
			}
			GUI.color = Color.white;
		}

		private static void DrawStatus()
		{
			//IL_0022: 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_00a2: 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_0069: 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_00ce: 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)
			//IL_0159: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: 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_01f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0202: Unknown result type (might be due to invalid IL or missing references)
			//IL_0207: Unknown result type (might be due to invalid IL or missing references)
			//IL_021d: Unknown result type (might be due to invalid IL or missing references)
			//IL_017a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0236: Unknown result type (might be due to invalid IL or missing references)
			//IL_024c: Unknown result type (might be due to invalid IL or missing references)
			//IL_027e: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b8: 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_02ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_036e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0320: Unknown result type (might be due to invalid IL or missing references)
			//IL_0319: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ae: Unknown result type (might be due to invalid IL or missing references)
			int y = 12;
			L("Ender's Ultimate Fish Warden Admin Mod".ToUpperInvariant() + " 2.0.0  build " + Plugin.BuiltAt(), Head);
			if (!TackleCheck.Passed)
			{
				L("NOT WORKING - the game changed and the guard could not attach.", Bad);
				{
					foreach (string failure in TackleCheck.Failures)
					{
						L("   " + failure, Bad);
					}
					return;
				}
			}
			L(Policy.Spell(), (Plugin.CurrentLevel == Level.Watch) ? Warn : Good);
			if (Plugin.CurrentLevel >= Level.Strict)
			{
				L(Plugin.AutoKick.Value ? "   removals happen immediately" : "   removals wait for you to approve", Dim);
			}
			if (Rules.DisabledCount > 0)
			{
				L("   not checking: " + string.Join(", ", Rules.Disabled), Dim);
			}
			if (!HostTools.FriendlyFire && Plugin.IsHosting)
			{
				L("Friendly fire is OFF - players cannot hurt each other.", Dim);
			}
			string text = Safety.Status();
			if (text != null)
			{
				L(text, Safety.Tripped ? Bad : Warn);
			}
			if (!Plugin.IsHosting)
			{
				L("You are a guest - you cannot enforce here, only watch.", Dim);
				IReadOnlyDictionary<string, int> suspects = ClientWatch.Suspects;
				if (suspects.Count == 0)
				{
					L("   nothing unusual seen so far", Dim);
					return;
				}
				{
					foreach (KeyValuePair<string, int> item in suspects)
					{
						L($"   {item.Key}: {item.Value} anomalies", Warn);
					}
					return;
				}
			}
			if (Cases.PendingCount > 0)
			{
				y += 4;
				Color c = Color.Lerp(Urgent, Bad, _pulse);
				L($">> {Cases.PendingCount} PERSON(S) WAITING ON YOUR DECISION - press F4", c);
			}
			string text2 = Extras.Status();
			if (text2.Length > 0)
			{
				L(text2, Warn);
			}
			string text3 = Cases.Noisy();
			if (text3 != null)
			{
				L(text3, Warn);
			}
			string text4 = Smite.AimedName();
			if (text4 != null)
			{
				y += 4;
				L("PageUp smites: " + text4, Urgent);
			}
			Dictionary<ulong, int> dictionary = Logbook.Tally();
			y += 4;
			if (dictionary.Count == 0)
			{
				L("Nobody flagged. Clean water.", Good);
			}
			else
			{
				L("Flagged:", Head);
				foreach (KeyValuePair<ulong, int> item2 in dictionary)
				{
					L($"   {Logbook.Name(item2.Key),-22} {item2.Value,3} strikes", (item2.Value >= Plugin.KickThreshold.Value) ? Bad : Warn);
				}
			}
			List<Entry> list = Logbook.Tail(5);
			if (list.Count <= 0)
			{
				return;
			}
			y += 4;
			L("Just now:", Head);
			foreach (Entry item3 in list)
			{
				L("   " + item3.Line, (item3.Verdict.Confidence == Confidence.Certain) ? Bad : Dim);
			}
			void L(string s, Color color)
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				//IL_001c: Unknown result type (might be due to invalid IL or missing references)
				GUI.color = color;
				GUI.Label(new Rect(12f, (float)y, 900f, 22f), s, _left);
				y += 19;
			}
		}

		private static void DrawHelp()
		{
			//IL_000e: 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_003d: 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_006b: Unknown result type (might be due to invalid IL or missing references)
			int num = Screen.width - 430 - 12;
			GUI.color = Head;
			GUI.Label(new Rect((float)num, 12f, 430f, 22f), "F4  -  open the console", _right);
			GUI.color = Dim;
			GUI.Label(new Rect((float)num, 31f, 430f, 22f), "F3 hides this", _right);
			GUI.color = Color.white;
		}
	}
	internal static class PlayerListGuard
	{
		private static int _lastReported;

		internal static void Sweep()
		{
			if (Plugin.PruneBrokenPlayers.Value)
			{
				int num = 0;
				num += Prune(PlayerManager.AlivePlayers);
				num += Prune(PlayerManager.Players);
				num += Prune(PlayerManager.OtherPlayers);
				if (num > 0)
				{
					_lastReported += num;
					Plugin.Log.LogWarning((object)($"[PlayerListGuard] dropped {num} player entry/entries with a missing Transform " + "(these break boat buoyancy and NPC targeting)."));
				}
			}
		}

		private static int Prune(List<Player> list)
		{
			if (list == null)
			{
				return 0;
			}
			int num = 0;
			for (int num2 = list.Count - 1; num2 >= 0; num2--)
			{
				Player val = list[num2];
				if ((Object)(object)val == (Object)null || (Object)(object)val.Transform == (Object)null)
				{
					list.RemoveAt(num2);
					num++;
				}
			}
			return num;
		}
	}
	[BepInPlugin("com.brade.fishwarden", "Ender's Ultimate Fish Warden Admin Mod", "2.0.0")]
	public class Plugin : BaseUnityPlugin
	{
		public const string PluginGuid = "com.brade.fishwarden";

		public const string PluginName = "Ender's Ultimate Fish Warden Admin Mod";

		public const string ShortName = "Fish Warden";

		public const bool HasExploits = true;

		public const string PluginVersion = "2.0.0";

		public static Plugin Instance;

		public static ManualLogSource Log;

		public static ConfigEntry<int> MaxPlausibleDamage;

		public static ConfigEntry<float> MaxWorthMultiplier;

		public static ConfigEntry<float> ImpossibleWorthMultiplier;

		public static ConfigEntry<int> KickThreshold;

		public static ConfigEntry<bool> AnnounceFindings;

		public static ConfigEntry<bool> EnforceBans;

		public static ConfigEntry<bool> GutOnRemoval;

		public static ConfigEntry<string> StartMode;

		public static ConfigEntry<string> DisabledRules;

		public static ConfigEntry<float> DamageTolerance;

		public static ConfigEntry<int> MinimumDamageCeiling;

		public static ConfigEntry<int> AssumedPunchDamage;

		public static ConfigEntry<float> AssumedPvpScale;

		public static ConfigEntry<float> AssumedHeadshotMulti;

		public static ConfigEntry<float> WorthRepeatGrace;

		public static ConfigEntry<int> ChargesShown;

		public static ConfigEntry<float> ReportInterval;

		public static ConfigEntry<float> CatalogueRefresh;

		public static ConfigEntry<float> VanillaWorthCeiling;

		public static ConfigEntry<float> SelfReviveWindow;

		public static ConfigEntry<int> SelfRevivesForProof;

		public static ConfigEntry<int> HandoversPerMinute;

		public static ConfigEntry<bool> BlockCrashPackets;

		public static ConfigEntry<bool> Quiet;

		public static ConfigEntry<int> EatsPerMinute;

		public static ConfigEntry<int> ProjectilesPerMinute;

		public static ConfigEntry<int> MaxProjectilesPerShot;

		public static ConfigEntry<int> BaitReleasesPerMinute;

		public static ConfigEntry<bool> TraceUnguarded;

		public static ConfigEntry<bool> TraceChatty;

		public static ConfigEntry<bool> TraceEverything;

		public static ConfigEntry<float> TraceInterval;

		public static ConfigEntry<int> PurchasesPerMinute;

		public static ConfigEntry<int> HitsPerMinute;

		public static ConfigEntry<int> ExplosivesPerMinute;

		public static ConfigEntry<int> ChatPerMinute;

		public static ConfigEntry<int> CosmeticPerMinute;

		public static ConfigEntry<int> BetsPerMinute;

		public static ConfigEntry<bool> WatchAim;

		public static ConfigEntry<bool> CheckLineOfSight;

		public static ConfigEntry<int> BlockedShotsForFinding;

		public static ConfigEntry<float> LineOfSightMinDistance;

		public static ConfigEntry<float> LineOfSightPadding;

		public static ConfigEntry<int> LineOfSightMask;

		public static ConfigEntry<int> AccuracySampleSize;

		public static ConfigEntry<float> SuspiciousAccuracy;

		public static ConfigEntry<bool> WatchReach;

		public static ConfigEntry<float> ReachTolerance;

		public static ConfigEntry<float> ReachSlack;

		public static ConfigEntry<float> MeleeReachSlack;

		public static ConfigEntry<float> MaxShotDistance;

		public static ConfigEntry<float> MaxMeleeDistance;

		public static ConfigEntry<bool> WatchFiring;

		public static ConfigEntry<float> FireRateTolerance;

		public static ConfigEntry<int> FastShotsForProof;

		public static ConfigEntry<float> MagTolerance;

		public static ConfigEntry<float> MovementSampleInterval;

		public static ConfigEntry<bool> WatchMovement;

		public static ConfigEntry<float> SlackLine;

		public static ConfigEntry<int> SpeedSamples;

		public static ConfigEntry<float> FlightSeconds;

		public static ConfigEntry<float> MaxJumpHeight;

		public static ConfigEntry<float> WaterWalkFloor;

		public static ConfigEntry<float> WaterWalkBand;

		public static ConfigEntry<float> WaterWalkSeconds;

		public static ConfigEntry<float> WaterWalkWobble;

		public static ConfigEntry<bool> PutFlyersDown;

		public static ConfigEntry<int> CorrectionsBeforeProof;

		public static ConfigEntry<bool> CheckNoclip;

		public static ConfigEntry<float> NoclipMinStep;

		public static ConfigEntry<float> NoclipPadding;

		public static ConfigEntry<float> NoclipProbeHeight;

		public static ConfigEntry<int> NoclipCrossingsForFinding;

		public static ConfigEntry<float> NoclipMinThickness;

		public static ConfigEntry<float> FlightActionCooldown;

		public static ConfigEntry<float> MovementFindingCooldown;

		public static ConfigEntry<float> FallbackSpeedCeiling;

		public static ConfigEntry<bool> Anchor;

		public static ConfigEntry<float> AnchorMinDistance;

		public static ConfigEntry<float> IslandGraceSeconds;

		public static ConfigEntry<bool> WatchAsClient;

		public static ConfigEntry<string> ChumItem;

		public static ConfigEntry<float> ChumHeight;

		public static ConfigEntry<float> CoolerInterval;

		public static ConfigEntry<int> BlowbackDamage;

		public static ConfigEntry<float> BlowbackLaunch;

		public static ConfigEntry<float> ButterfingersInterval;

		public static ConfigEntry<float> FreezeInterval;

		public static ConfigEntry<bool> MuteAnnounce;

		public static ConfigEntry<bool> MuteSpeaksAsPlayer;

		public static ConfigEntry<float> MuteNoticeInterval;

		public static ConfigEntry<bool> PruneBrokenPlayers;

		public static ConfigEntry<bool> FixJoining;

		public static ConfigEntry<bool> NativeConsole;

		public static ConfigEntry<string> Backdrop;

		public static ConfigEntry<Action> ProvenCosts;

		public static ConfigEntry<Action> SuspicionCosts;

		public static ConfigEntry<string> AutoTrollMode;

		public static ConfigEntry<int> AutoTrollStrikes;

		public static ConfigEntry<string> AutoTrollRules;

		public static ConfigEntry<float> TrollJostleInterval;

		public static ConfigEntry<float> TrollIdleInterval;

		public static ConfigEntry<float> TrollReactInterval;

		public static ConfigEntry<int> TrollTier2;

		public static ConfigEntry<int> TrollTier3;

		public static ConfigEntry<float> GroundedProbe;

		public static ConfigEntry<float> TrollJostleRadius;

		public static ConfigEntry<bool> TrollTaunts;

		public static ConfigEntry<float> GroundProbeDistance;

		public static ConfigEntry<float> LockerDistance;

		public static ConfigEntry<bool> CaptureEvidence;

		public static ConfigEntry<float> EvidenceCooldown;

		public static ConfigEntry<int> EvidenceSessionCap;

		public static ConfigEntry<bool> AutoKick;

		public static ConfigEntry<float> CaseExpiryMinutes;

		public static ConfigEntry<int> NoisyRuleThreshold;

		public static ConfigEntry<float> WarmupMinutes;

		public static ConfigEntry<int> BreakerPlayers;

		public static ConfigEntry<float> BreakerMinutes;

		public static ConfigEntry<int> RuleStormCount;

		public static ConfigEntry<int> RpcsPerSecond;

		public static ConfigEntry<int> LobbySize;

		public static ConfigEntry<int> WorthsPerMinute;

		public static ConfigEntry<string> BlockOff;

		public static ConfigEntry<string> TrollOn;

		public static ConfigEntry<string> TrollOff;

		public static ConfigEntry<float> AnswerCooldown;

		public static ConfigEntry<float> RuleStormMinutes;

		public static ConfigEntry<bool> RequireProofToRemove;

		public static ConfigEntry<string> AppealTo;

		public static ConfigEntry<float> SmiteFov;

		public static ConfigEntry<float> SmiteRange;

		public static ConfigEntry<int> SmiteDamage;

		public static ConfigEntry<float> SmiteLaunch;

		public static ConfigEntry<float> SmiteCooldown;

		public static ConfigEntry<float> FlySpeed;

		public static ConfigEntry<float> FlyBoost;

		private static ConfigEntry<KeyboardShortcut> _fly;

		private static ConfigEntry<KeyboardShortcut> _islandNext;

		private static ConfigEntry<KeyboardShortcut> _islandPrev;

		private static ConfigEntry<KeyboardShortcut> _smite;

		private static ConfigEntry<KeyboardShortcut> _dashboard;

		private static ConfigEntry<KeyboardShortcut> _toggleHelp;

		private static ConfigEntry<KeyboardShortcut> _panic;

		private static ConfigEntry<KeyboardShortcut> _toggleOverlay;

		private static ConfigEntry<KeyboardShortcut> _cycleMode;

		private static bool _sessionOpen;

		private float _nextSweep;

		public static Level CurrentLevel { get; private set; } = Level.Block;

		public static bool IsHosting
		{
			get
			{
				try
				{
					return (Object)(object)Server.Instance != (Object)null && ((NetworkBehaviour)Server.Instance).IsServerInitialized;
				}
				catch
				{
					return false;
				}
			}
		}

		public static int Armed { get; private set; }

		public static int NotArmed { get; private set; }

		public static string KeyLabel(string binding)
		{
			//IL_013b: 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_0159: Unknown result type (might be due to invalid IL or missing references)
			//IL_015e: 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_0192: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if (binding != null)
				{
					int length = binding.Length;
					ConfigEntry<KeyboardShortcut> val;
					if (length <= 5)
					{
						if (length != 3)
						{
							if (length != 5)
							{
								goto IL_0122;
							}
							char c = binding[0];
							if (c != 'P')
							{
								if (c != 'S' || !(binding == "Smite"))
								{
									goto IL_0122;
								}
								val = _smite;
							}
							else
							{
								if (!(binding == "Panic"))
								{
									goto IL_0122;
								}
								val = _panic;
							}
						}
						else
						{
							if (!(binding == "Fly"))
							{
								goto IL_0122;
							}
							val = _fly;
						}
					}
					else if (length != 9)
					{
						if (length != 10)
						{
							goto IL_0122;
						}
						char c = binding[0];
						if (c != 'N')
						{
							if (c != 'P' || !(binding == "PrevIsland"))
							{
								goto IL_0122;
							}
							val = _islandPrev;
						}
						else
						{
							if (!(binding == "NextIsland"))
							{
								goto IL_0122;
							}
							val = _islandNext;
						}
					}
					else
					{
						char c = binding[0];
						if (c != 'C')
						{
							if (c != 'D' || !(binding == "Dashboard"))
							{
								goto IL_0122;
							}
							val = _dashboard;
						}
						else
						{
							if (!(binding == "CycleMode"))
							{
								goto IL_0122;
							}
							val = _cycleMode;
						}
					}
					if (val == null)
					{
						return "";
					}
					KeyboardShortcut value = val.Value;
					string text = "";
					foreach (KeyCode modifier in ((KeyboardShortcut)(ref value)).Modifiers)
					{
						text = text + Pretty(modifier) + "+";
					}
					return "   (" + text + Pretty(((KeyboardShortcut)(ref value)).MainKey) + ")";
				}
				goto IL_0122;
				IL_0122:
				return "";
			}
			catch
			{
				return "";
			}
		}

		private unsafe static string Pretty(KeyCode k)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Invalid comparison between Unknown and I4
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Invalid comparison between Unknown and I4
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Invalid comparison between Unknown and I4
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Invalid comparison between Unknown and I4
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Invalid comparison between Unknown and I4
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Expected I4, but got Unknown
			if ((int)k <= 46)
			{
				if ((int)k == 44)
				{
					return ",";
				}
				if ((int)k == 46)
				{
					return ".";
				}
			}
			else
			{
				if ((int)k == 280)
				{
					return "PgUp";
				}
				if ((int)k == 281)
				{
					return "PgDn";
				}
				switch (k - 303)
				{
				case 1:
					return "Shift";
				case 0:
					return "Shift";
				case 3:
					return "Ctrl";
				case 2:
					return "Ctrl";
				case 5:
					return "Alt";
				case 4:
					return "Alt";
				}
			}
			return ((object)(*(KeyCode*)(&k))/*cast due to .constrained prefix*/).ToString();
		}

		public static string BuiltAt()
		{
			try
			{
				string location = typeof(Plugin).Assembly.Location;
				if (string.IsNullOrEmpty(location))
				{
					return "";
				}
				return new FileInfo(location).LastWriteTime.ToString("HH:mm");
			}
			catch
			{
				return "";
			}
		}

		public static string BuildStamp()
		{
			try
			{
				string location = typeof(Plugin).Assembly.Location;
				if (string.IsNullOrEmpty(location))
				{
					return "build stamp unavailable.";
				}
				FileInfo fileInfo = new FileInfo(location);
				return "running " + fileInfo.Name + " built " + fileInfo.LastWriteTime.ToString("yyyy-MM-dd HH:mm:ss") + " (" + fileInfo.Length / 1024 + "KB). If a fix is missing, check this line first - BepInEx only loads plugins at startup, so a DLL deployed into a running game does nothing until you restart.";
			}
			catch (Exception ex)
			{
				return "build stamp unavailable: " + ex.Message;
			}
		}

		private void Awake()
		{
			Instance = this;
			Log = ((BaseUnityPlugin)this).Logger;
			Bind();
			if (Enum.TryParse<Level>(StartMode.Value, ignoreCase: true, out var result))
			{
				CurrentLevel = result;
			}
			Policy.Load();
			if (Policy.CurrentName() != "Custom")
			{
				Policy.Adopt(CurrentLevel);
			}
			else
			{
				Log.LogInfo((object)("[Fishwarden] keeping a custom policy: " + Policy.Spell()));
			}
			Rules.Load();
			Log.LogInfo((object)"Ender's Ultimate Fish Warden Admin Mod v2.0.0 loading...");
			if (!TackleCheck.Run())
			{
				Log.LogError((object)"[Fishwarden] disarmed - no patches applied. See above.");
				return;
			}
			try
			{
				ReportConfigDrift();
				ApplyPatches();
				Bans.Load();
				Log.LogInfo((object)("Ender's Ultimate Fish Warden Admin Mod v2.0.0 armed. " + TackleCheck.Summary() + ". " + Policy.Explain(CurrentLevel)));
				Log.LogInfo((object)"[Fishwarden] F4 opens the console. F1 readout, F2 cycles mode.");
				Log.LogInfo((object)("[Fishwarden] " + BuildStamp()));
			}
			catch (Exception ex)
			{
				Log.LogError((object)("[Fishwarden] patching failed, guard is NOT active: " + ex));
			}
		}

		private void Bind()
		{
			//IL_1198: Unknown result type (might be due to invalid IL or missing references)
			//IL_11c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_11f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_131b: Unknown result type (might be due to invalid IL or missing references)
			//IL_1346: Unknown result type (might be due to invalid IL or missing references)
			//IL_1371: Unknown result type (might be due to invalid IL or missing references)
			//IL_139f: Unknown result type (might be due to invalid IL or missing references)
			//IL_13cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_13fb: Unknown result type (might be due to invalid IL or missing references)
			MaxPlausibleDamage = ((BaseUnityPlugin)this).Config.Bind<int>("Guard", "MaxPlausibleDamage", 2000, "Damage above this in one packet is fabricated. A fully upgraded sniper reaches ~750, so this sits well clear of real weapons while still catching the 99999 that cheats send. Ignored entirely while the lobby's own one-shot setting is on.");
			ImpossibleWorthMultiplier = ((BaseUnityPlugin)this).Config.Bind<float>("Guard", "ImpossibleWorthMultiplier", 50f, "Above this, a sell multiplier is treated as PROVEN cheating. The game pays a bonus for a stylish kill, so an unusual multiplier is not proof of anything - but nothing in the game pays fifty times. Between this and MaxWorthMultiplier a finding is suspicious rather than proven.");
			MaxWorthMultiplier = ((BaseUnityPlugin)this).Config.Bind<float>("Guard", "MaxWorthMultiplier", 5f, "Sell-value multiplier above this is treated as fabricated.");
			KickThreshold = ((BaseUnityPlugin)this).Config.Bind<int>("Guard", "KickThreshold", 20, "Strike total that triggers removal in Keepers Only. Certain=10, strong=3, maybe=1.");
			AnnounceFindings = ((BaseUnityPlugin)this).Config.Bind<bool>("Guard", "AnnounceInChat", true, "Announce Certain-tier findings in chat so unmodded players see who it is. Weaker tiers are never announced.");
			EnforceBans = ((BaseUnityPlugin)this).Config.Bind<bool>("Guard", "EnforceBans", true, "Add removed players to the trophy wall and refuse them on rejoin.");
			GutOnRemoval = ((BaseUnityPlugin)this).Config.Bind<bool>("Guard", "GutOnRemoval", true, "Undo a removed player's damage - their spawns, inflated values, and kills.");
			StartMode = ((BaseUnityPlugin)this).Config.Bind<string>("Guard", "StartLevel", "Block", "Watch, Block, Strict or Lockdown. Block stops proven cheats and removes nobody - the right default for a public lobby.");
			DamageTolerance = ((BaseUnityPlugin)this).Config.Bind<float>("Guard", "DamageTolerance", 1.5f, "How far above their own weapon's damage a hit may go before it counts as fabricated. Headroom for crits and effects we have not traced.");
			MinimumDamageCeiling = ((BaseUnityPlugin)this).Config.Bind<int>("Guard", "MinimumDamageCeiling", 60, "Safety floor used ONLY when a weapon's real damage cannot be read. A player has 100 health, so this must stay well under that - a floor above it silently allows one-shotting.");
			ChargesShown = ((BaseUnityPlugin)this).Config.Bind<int>("Console", "ChargesShown", 6, "How many of a player's most recent findings the Warden panel lists when you select them. Each one shows the rule, whether it was blocked, and the sentence the rule wrote.");
			WorthRepeatGrace = ((BaseUnityPlugin)this).Config.Bind<float>("Guard", "WorthRepeatGraceSeconds", 1.5f, "How soon after a kill a second sell-value multiplier on the same item is treated as the same kill rather than a second claim. Several hits landing in one frame each run the creature's death branch, so one shotgun blast on one fish legitimately sends several. Real inflation comes back later.");
			AssumedHeadshotMulti = ((BaseUnityPlugin)this).Config.Bind<float>("Guard", "AssumedHeadshotMultiplier", 3f, "Fallback for how much a headshot multiplies damage against a creature, used only if GameInfo.HeadShotDamageMulti cannot be read. Creature.LocalHit applies it before sending, so without it every headshot on a fish looks like damage above what the weapon allows.");
			AssumedPvpScale = ((BaseUnityPlugin)this).Config.Bind<float>("Guard", "AssumedPvpDamageScale", 0.25f, "Fraction of a weapon's damage that actually lands on a PLAYER, used only if the real value cannot be read. The game scales PvP damage down before sending it.");
			AssumedPunchDamage = ((BaseUnityPlugin)this).Config.Bind<int>("Guard", "AssumedPunchDamage", 25, "Fallback bare-handed damage when the real value cannot be read.");
			ReportInterval = ((BaseUnityPlugin)this).Config.Bind<float>("Guard", "SecondsBetweenRepeatReports", 5f, "One log line, announcement and screenshot per player per rule per this many seconds. Repeats are still blocked - only the reporting is throttled, because reporting every packet is what crashed the server.");
			CatalogueRefresh = ((BaseUnityPlugin)this).Config.Bind<float>("Guard", "CatalogueRefreshSeconds", 20f, "How often the list of what shops sell is rebuilt. Stands are scene objects, so it has to survive an island change.");
			VanillaWorthCeiling = ((BaseUnityPlugin)this).Config.Bind<float>("Guard", "VanillaWorthCeiling", 2f, "Sell multipliers up to this are normal play - the game sets a small one on ordinary catches. Below this, nothing is even noted.");
			SelfReviveWindow = ((BaseUnityPlugin)this).Config.Bind<float>("Guard", "SelfReviveWindow", 20f, "Seconds over which repeated self-revives are counted.");
			SelfRevivesForProof = ((BaseUnityPlugin)this).Config.Bind<int>("Guard", "SelfRevivesForProof", 3, "Self-revives inside that window before it counts as proof rather than suspicion.");
			HandoversPerMinute = ((BaseUnityPlugin)this).Config.Bind<int>("CatchLimit", "PhysicsHandoversPerMinute", 240, "HandOverItemSimulation calls per minute. One live session saw 2113 from a single player.");
			BlockCrashPackets = ((BaseUnityPlugin)this).Config.Bind<bool>("Guard", "BlockCrashPackets", true, "Drop spawn packets carrying an out-of-range skin index. These crash every OTHER client in the lobby, so they are blocked at every level including Watch.");
			Quiet = ((BaseUnityPlugin)this).Config.Bind<bool>("Guard", "Quiet", false, "Block without announcing anything in chat. The cheat just fails, with nothing confirming an anti-cheat is watching. You still see everything.");
			EatsPerMinute = ((BaseUnityPlugin)this).Config.Bind<int>("CatchLimit", "EatsPerMinute", 30, "");
			ProjectilesPerMinute = ((BaseUnityPlugin)this).Config.Bind<int>("CatchLimit", "ProjectilesPerMinute", 600, "");
			MaxProjectilesPerShot = ((BaseUnityPlugin)this).Config.Bind<int>("CatchLimit", "MaxProjectilesPerShot", 64, "Most projectiles one shot may carry. This exists to catch hundreds in a packet - an attempt to bury the server - not to police a spread. It was 24, and a shotgun fires 25, so the first honest shotgun in the lobby was called proven cheating. Set well clear of any real weapon; the log reports the highest honest count it has seen.");
			BaitReleasesPerMinute = ((BaseUnityPlugin)this).Config.Bind<int>("CatchLimit", "BaitReleasesPerMinute", 60, "");
			TraceUnguarded = ((BaseUnityPlugin)this).Config.Bind<bool>("Trace", "Enabled", true, "Log the client RPCs that have no rule yet, so a gap in cover shows up instead of passing silently.");
			TraceEverything = ((BaseUnityPlugin)this).Config.Bind<bool>("Trace", "LogAllTraffic", false, "Log EVERY client RPC, including ones we already guard. Very noisy, and the only way to find an exploit whose shape no rule recognises. Turn on, reproduce it once, turn off.");
			TraceChatty = ((BaseUnityPlugin)this).Config.Bind<bool>("Trace", "IncludeRelays", false, "Also tap the position and animation relays. Very noisy - only for hunting something specific.");
			TraceInterval = ((BaseUnityPlugin)this).Config.Bind<float>("Trace", "SecondsBetweenLines", 10f, "One line per player per RPC per this many seconds.");
			DisabledRules = ((BaseUnityPlugin)this).Config.Bind<string>("Guard", "DisabledRules", "", "Comma-separated rule names to stop checking entirely, e.g. item-move,speed. Set from the dashboard.");
			PurchasesPerMinute = ((BaseUnityPlugin)this).Config.Bind<int>("CatchLimit", "PurchasesPerMinute", 20, "How many things one player may buy in a minute. Was 40, which did not slow down somebody spawning in bulk; 12 was briefly tried and would have caught an honest player stocking up on bait and ammo. 20 sits between the two. This only refuses the purchase - nobody is removed for shopping. 0 disables this check.");
			HitsPerMinute = ((BaseUnityPlugin)this).Config.Bind<int>("CatchLimit", "HitsPerMinute", 400, "Melee swings, punches and creature hits.");
			ExplosivesPerMinute = ((BaseUnityPlugin)this).Config.Bind<int>("CatchLimit", "ExplosivesPerMinute", 20, "");
			ChatPerMinute = ((BaseUnityPlugin)this).Config.Bind<int>("CatchLimit", "ChatPerMinute", 30, "");
			CosmeticPerMinute = ((BaseUnityPlugin)this).Config.Bind<int>("CatchLimit", "CosmeticPerMinute", 30, "Skin changes.");
			BetsPerMinute = ((BaseUnityPlugin)this).Config.Bind<int>("CatchLimit", "BetsPerMinute", 60, "");
			WatchAim = ((BaseUnityPlugin)this).Config.Bind<bool>("Aim", "Enabled", true, "Watch what aimbotting produces. The aiming itself is camera rotation on their machine and no packet carries it - these are consequences, not the act.");
			CheckLineOfSight = ((BaseUnityPlugin)this).Config.Bind<bool>("Aim", "CheckLineOfSight", true, "Flag hits that had solid geometry in the way. Catches wall-aimbots.");
			BlockedShotsForFinding = ((BaseUnityPlugin)this).Config.Bind<int>("Aim", "BlockedShotsForFinding", 4, "Blocked-line hits before it counts. One is a clipping muzzle or a target against cover.");
			LineOfSightMinDistance = ((BaseUnityPlugin)this).Config.Bind<float>("Aim", "MinDistance", 6f, "Ignore hits closer than this - point blank is always ambiguous.");
			LineOfSightPadding = ((BaseUnityPlugin)this).Config.Bind<float>("Aim", "Padding", 1.5f, "Metres trimmed from each end of the line, so muzzles inside walls and targets leaning on them do not read as cheating.");
			LineOfSightMask = ((BaseUnityPlugin)this).Config.Bind<int>("Aim", "LayerMask", -1, "Physics layers treated as solid. Default is everything; narrow it if terrain gives false positives.");
			AccuracySampleSize = ((BaseUnityPlugin)this).Config.Bind<int>("Aim", "AccuracySampleSize", 60, "Shots per accuracy window. Only ever produces a hint, never an action.");
			SuspiciousAccuracy = ((BaseUnityPlugin)this).Config.Bind<float>("Aim", "SuspiciousAccuracy", 0.97f, "Hit rate over that window that looks inhuman.");
			WatchReach = ((BaseUnityPlugin)this).Config.Bind<bool>("Reach", "Enabled", true, "Check that an attacker was close enough to their target. Catches acting from somewhere other than where you appear, long-range aimbotting, and teleport-strike.");
			ReachTolerance = ((BaseUnityPlugin)this).Config.Bind<float>("Reach", "Tolerance", 2f, "Multiplier on the weapon's real range before a hit counts as impossible.");
			ReachSlack = ((BaseUnityPlugin)this).Config.Bind<float>("Reach", "SlackMetres", 25f, "Flat metres added on top, absorbing the position disagreement two machines always have.");
			MeleeReachSlack = ((BaseUnityPlugin)this).Config.Bind<float>("Reach", "MeleeSlackMetres", 2.5f, "Slack for melee and fists. Must stay small - the ranged figure applied to a punch allows a stretched arm to reach across a dock.");
			MaxShotDistance = ((BaseUnityPlugin)this).Config.Bind<float>("Reach", "FallbackGunRange", 300f, "Used when a gun's own range cannot be read.");
			MaxMeleeDistance = ((BaseUnityPlugin)this).Config.Bind<float>("Reach", "FallbackMeleeRange", 6f, "Used when a melee or punch reach cannot be read.");
			WatchFiring = ((BaseUnityPlugin)this).Config.Bind<bool>("Firing", "Enabled", true, "Watch how fast people shoot and how many rounds they get from a magazine. Ammo itself is invisible to the server; this catches what it produces.");
			FireRateTolerance = ((BaseUnityPlugin)this).Config.Bind<float>("Firing", "RateTolerance", 0.6f, "Fraction of a weapon's real cooldown that still counts as legitimate. 0.6 means shots must be at least 60% of the proper gap apart.");
			FastShotsForProof = ((BaseUnityPlugin)this).Config.Bind<int>("Firing", "FastShotsForProof", 6, "Shots in a row faster than the weapon allows before it counts. One early shot is jitter; a run of them is no cooldown at all.");
			MagTolerance = ((BaseUnityPlugin)this).Config.Bind<float>("Firing", "MagazineTolerance", 1.5f, "How far past the magazine size a player may go before it counts, allowing for a reload we did not see.");
			MovementSampleInterval = ((BaseUnityPlugin)this).Config.Bind<float>("Movement", "SampleInterval", 0.2f, "Seconds between position samples. Read from transforms on the host, so it does not depend on any particular RPC carrying position.");
			WatchMovement = ((BaseUnityPlugin)this).Config.Bind<bool>("Movement", "Enabled", true, "Watch position relays for speed and flight. Never produces a Certain finding on its own.");
			SlackLine = ((BaseUnityPlugin)this).Config.Bind<float>("Movement", "SlackLine", 1.6f, "Tolerance multiplier on the speed ceiling. Raise for a laggy lobby rather than turning the check off.");
			SpeedSamples = ((BaseUnityPlugin)this).Config.Bind<int>("Movement", "ConsecutiveSamples", 5, "Bad samples in a row before a speed finding. One spike is lag, not a cheat.");
			FlightSeconds = ((BaseUnityPlugin)this).Config.Bind<float>("Movement", "FlightSeconds", 2.5f, "Airborne with no boat for this long counts as flight.");
			MaxJumpHeight = ((BaseUnityPlugin)this).Config.Bind<float>("Movement", "MaxJumpHeight", 9f, "Metres above the water no ordinary jump can reach. Above this with no boat is flight.");
			WaterWalkFloor = ((BaseUnityPlugin)this).Config.Bind<float>("Movement", "WaterWalkFloor", 0.35f, "Must be at least this far ABOVE the surface. Below it they are swimming, which is not a cheat - checking absolute distance flagged every swimmer.");
			WaterWalkBand = ((BaseUnityPlugin)this).Config.Bind<float>("Movement", "WaterWalkBand", 2.5f, "Upper edge of the band. Above this the altitude rule handles it.");
			WaterWalkWobble = ((BaseUnityPlugin)this).Config.Bind<float>("Movement", "WaterWalkWobble", 0.6f, "How much a player's height above the water may vary and still count as STANDING on it, in metres. Walking on water holds one height; jumping does not. Raise it if somebody hovering is getting away with it, lower it if jumping near the shore is being flagged.");
			WaterWalkSeconds = ((BaseUnityPlugin)this).Config.Bind<float>("Movement", "WaterWalkSeconds", 5f, "Seconds held at the surface before it counts. A wave or a jump over water is brief; standing there is not.");
			PutFlyersDown = ((BaseUnityPlugin)this).Config.Bind<bool>("Movement", "PutFlyersDown", true, "Teleport a confirmed flyer back to the last ground they stood on. Dropping their packets does nothing - their own machine simulates movement - so overruling them is the only lever the host has.");
			CorrectionsBeforeProof = ((BaseUnityPlugin)this).Config.Bind<int>("Movement", "CorrectionsBeforeProof", 6, "Times a player is put back on the ground before it stops being a judgement call. Lag does not do this repeatedly.");
			CheckNoclip = ((BaseUnityPlugin)this).Config.Bind<bool>("Movement", "CheckNoclip", true, "Flag moving through solid geometry between position samples.");
			NoclipMinStep = ((BaseUnityPlugin)this).Config.Bind<float>("Movement", "NoclipMinStep", 1.2f, "Ignore steps shorter than this - short moves clip stairs and doorframes.");
			NoclipPadding = ((BaseUnityPlugin)this).Config.Bind<float>("Movement", "NoclipPadding", 0.4f, "Metres trimmed from each end of the probe.");
			NoclipProbeHeight = ((BaseUnityPlugin)this).Config.Bind<float>("Movement", "NoclipProbeHeight", 1f, "Probe at waist height, so floors and small steps are not read as walls.");
			NoclipMinThickness = ((BaseUnityPlugin)this).Config.Bind<float>("Movement", "NoclipMinThickness", 0.6f, "How thick the geometry between two samples must be to count as phasing through it, in metres. Walking over a crest, a ramp or a kerb dips the straight line a few centimetres under the surface, which is solid on any raycast and completely innocent. A wall is thicker than this; a hill you walked over is not.");
			NoclipCrossingsForFinding = ((BaseUnityPlugin)this).Config.Bind<int>("Movement", "NoclipCrossingsForFinding", 3, "Crossings before it counts. One is a ramp or a doorway.");
			FlightActionCooldown = ((BaseUnityPlugin)this).Config.Bind<float>("Movement", "SecondsBetweenCorrections", 1.2f, "Minimum gap between putting the same player down, so a fall is not fought mid-air.");
			MovementFindingCooldown = ((BaseUnityPlugin)this).Config.Bind<float>("Movement", "FindingCooldown", 15f, "Minimum seconds between movement findings for the same player.");
			FallbackSpeedCeiling = ((BaseUnityPlugin)this).Config.Bind<float>("Movement", "FallbackCeiling", 12f, "Used when a player's own sprint speed cannot be read.");
			Anchor = ((BaseUnityPlugin)this).Config.Bind<bool>("JoinSide", "Anchor", false, "Refuse teleports aimed at you. OFF by default: a wrong refusal leaves you stuck, so try it in Dry Run first.");
			AnchorMinDistance = ((BaseUnityPlugin)this).Config.Bind<float>("JoinSide", "AnchorMinDistance", 15f, "Only teleports moving you further than this are considered.");
			IslandGraceSeconds = ((BaseUnityPlugin)this).Config.Bind<float>("JoinSide", "IslandGraceSeconds", 8f, "Teleports are always allowed for this long after an island change - island travel moves everyone legitimately.");
			WatchAsClient = ((BaseUnityPlugin)this).Config.Bind<bool>("JoinSide", "FishFinder", true, "Watch other players for speed and flight while you are a guest. Local only, proves nothing, but gives you a name.");
			ChumItem = ((BaseUnityPlugin)this).Config.Bind<string>("Containment", "ChumItem", "Tuna", "Item used as the honeypot.");
			ChumHeight = ((BaseUnityPlugin)this).Config.Bind<float>("Containment", "ChumHeight", 80f, "How far above you the chum is placed. Must be unreachable without flight.");
			BlowbackDamage = ((BaseUnityPlugin)this).Config.Bind<int>("Containment", "BlowbackDamage", 99999, "Damage they take from their own attack. Applied with a null attacker, so it lands whether friendly fire is on or off.");
			BlowbackLaunch = ((BaseUnityPlugin)this).Config.Bind<float>("Containment", "BlowbackLaunch", 40f, "Upward force on the killing blow. Sends them into the air instead of just dropping them.");
			ButterfingersInterval = ((BaseUnityPlugin)this).Config.Bind<float>("Containment", "ButterfingersInterval", 2f, "Seconds between forcing them to drop whatever they picked up.");
			MuteAnnounce = ((BaseUnityPlugin)this).Config.Bind<bool>("Containment", "MuteAnnounce", true, "Post a line in chat when a muted player tries to talk, so the lobby knows something happened rather than just hearing nothing.");
			MuteSpeaksAsPlayer = ((BaseUnityPlugin)this).Config.Bind<bool>("Containment", "MuteSpeaksAsPlayer", true, "Send the replacement line AS the muted player rather than as the warden. Host only, in your own lobby, against somebody you have already muted.");
			MuteNoticeInterval = ((BaseUnityPlugin)this).Config.Bind<float>("Containment", "MuteNoticeInterval", 12f, "Seconds between those lines. Voice frames arrive many times a second.");
			FixJoining = ((BaseUnityPlugin)this).Config.Bind<bool>("Fixes", "FixBlackScreenOnJoin", true, "Player.InitializePlayer throws when a joiner's Client object has not spawned yet, and that exception aborts FishNet's whole spawn batch - which is the real cause of the black screen. Parks the player and re-runs it once the Client arrives.");
			NativeConsole = ((BaseUnityPlugin)this).Config.Bind<bool>("Interface", "NativeConsole", false, "Build the F4 console from the game's own menu prefabs instead of drawing it. Still being worked on - turn it on to try it, turn it off to get the plain one back.");
			ProvenCosts = ((BaseUnityPlugin)this).Config.Bind<Action>("Enforcement", "ProvenCosts", Action.Block, "What a PROVEN finding costs - one the vanilla client could not have produced. Log, Block or Remove.");
			SuspicionCosts = ((BaseUnityPlugin)this).Config.Bind<Action>("Enforcement", "SuspicionCosts", Action.Log, "What a SUSPICIOUS finding costs - one a laggy or unlucky player could trip. Log, Block or Remove. A hunch is never acted on whatever this says.");
			Backdrop = ((BaseUnityPlugin)this).Config.Bind<string>("Interface", "Backdrop", "", "OPTIONAL. Name one of the game's frosted materials to build the sheet on - 'Thinking', 'Underwater'. Empty (the default) uses the console's own tint, which looks the same in every scene. Borrowing does not: the material has to exist where you open the console, and it will not at the main menu.");
			PruneBrokenPlayers = ((BaseUnityPlugin)this).Config.Bind<bool>("Fixes", "FixSinkingBoat", true, "Dead entries with destroyed transforms sit in PlayerManager's lists and throw inside Boat.FixedUpdate before buoyancy is applied - so the boat sinks, then launches. Prunes them each frame.");
			FreezeInterval = ((BaseUnityPlugin)this).Config.Bind<float>("Containment", "FreezeInterval", 0.25f, "Seconds between pinning a frozen player back to the spot. Movement is client-simulated, so holding somebody still means overruling them repeatedly.");
			AutoTrollMode = ((BaseUnityPlugin)this).Config.Bind<string>("Troll", "AutoArm", "Off", "Off, AnyProven, AfterStrikes or ChosenRules. Decides when troll mode turns itself on. It never fires on a guess in any mode.");
			AutoTrollStrikes = ((BaseUnityPlugin)this).Config.Bind<int>("Troll", "AutoArmStrikes", 20, "Strikes before AfterStrikes mode arms it.");
			AutoTrollRules = ((BaseUnityPlugin)this).Config.Bind<string>("Troll", "AutoArmRules", "auto-fire,no-reload,shot-through-wall,perfect-accuracy", "Comma-separated rules that arm it in ChosenRules mode. The defaults are the cheats that cannot be blocked, which is exactly what troll mode is for.");
			TrollJostleInterval = ((BaseUnityPlugin)this).Config.Bind<float>("Troll", "JostleInterval", 1.5f, "Seconds between shoving a trolled player. Frequent enough to spoil a locked aim.");
			TrollJostleRadius = ((BaseUnityPlugin)this).Config.Bind<float>("Troll", "JostleRadius", 2.5f, "How far each shove moves them. Small on purpose - annoying, never stranding.");
			TrollIdleInterval = ((BaseUnityPlugin)this).Config.Bind<float>("Troll", "IdleInterval", 30f, "Seconds between unprompted remarks when they have gone quiet.");
			TrollReactInterval = ((BaseUnityPlugin)this).Config.Bind<float>("Troll", "ReactInterval", 6f, "Minimum gap between reacting to what they just tried, so a spamming cheat does not flood chat.");
			TrollTier2 = ((BaseUnityPlugin)this).Config.Bind<int>("Troll", "Tier2Incidents", 8, "Incidents before the commentary gets less charitable.");
			TrollTier3 = ((BaseUnityPlugin)this).Config.Bind<int>("Troll", "Tier3Incidents", 20, "Incidents before it stops pretending to be polite.");
			GroundedProbe = ((BaseUnityPlugin)this).Config.Bind<float>("Movement", "GroundedProbe", 2.5f, "How far below a player counts as standing on something. Decided by raycast on the host, not from a client flag.");
			TrollTaunts = ((BaseUnityPlugin)this).Config.Bind<bool>("Troll", "Taunts", true, "Narrate their misfortune in lobby chat. Off by default - troll mode is driven from the dashboard, and chat spam gives the game away.");
			GroundProbeDistance = ((BaseUnityPlugin)this).Config.Bind<float>("Movement", "GroundProbeDistance", 300f, "How far down to look for ground when putting a flyer down who was never seen standing.");
			CoolerInterval = ((BaseUnityPlugin)this).Config.Bind<float>("Containment", "CoolerInterval", 3f, "Seconds between knockdowns for someone in the cooler.");
			LockerDistance = ((BaseUnityPlugin)this).Config.Bind<float>("Containment", "LockerDistance", 900f, "How far out to sea Davy Jones' locker is.");
			CaptureEvidence = ((BaseUnityPlugin)this).Config.Bind<bool>("Evidence", "CaptureScreenshots", true, "Screenshot each Certain-tier finding, for reporting to the developers.");
			EvidenceCooldown = ((BaseUnityPlugin)this).Config.Bind<float>("Evidence", "CooldownSeconds", 3f, "");
			EvidenceSessionCap = ((BaseUnityPlugin)this).Config.Bind<int>("Evidence", "SessionCap", 40, "");
			AutoKick = ((BaseUnityPlugin)this).Config.Bind<bool>("Safety", "AutoKick", false, "OFF: reaching the threshold opens a case for you to accept or dismiss. ON: it removes them immediately. Off is the right default for a public lobby.");
			CaseExpiryMinutes = ((BaseUnityPlugin)this).Config.Bind<float>("Safety", "CaseExpiryMinutes", 20f, "Unreviewed cases close on their own after this long. 0 keeps them forever.");
			NoisyRuleThreshold = ((BaseUnityPlugin)this).Config.Bind<int>("Safety", "NoisyRuleThreshold", 3, "Dismiss the same rule this many times and Fishwarden will tell you it is probably wrong.");
			WarmupMinutes = ((BaseUnityPlugin)this).Config.Bind<float>("Safety", "WarmupMinutes", 5f, "No blocking or kicking for this long after you start hosting, whatever the mode. A clean-session test that runs itself. 0 disables.");
			AnswerCooldown = ((BaseUnityPlugin)this).Config.Bind<float>("Enforcement", "AnswerCooldown", 20f, "Seconds between troll responses aimed at the same player. Without it, somebody spamming one rule is frozen, skunked, exploded and shamed inside two seconds, which reads as a malfunction rather than a joke.");
			BlockOff = ((BaseUnityPlugin)this).Config.Bind<string>("Enforcement", "NotRefused", "", "Rules whose findings are recorded but NOT refused. Everything is refused by default - this is the list of ones you have decided to let through.");
			TrollOn = ((BaseUnityPlugin)this).Config.Bind<string>("Enforcement", "AlsoAnswered", "", "Rules that get a troll response even though their family does not by default. Measured rules - flight, phasing, speed, magazine counting - are off by default because every false positive so far came from that group.");
			TrollOff = ((BaseUnityPlugin)this).Config.Bind<string>("Enforcement", "NeverAnswered", "", "Rules that get no troll response even though their family normally would.");
			WorthsPerMinute = ((BaseUnityPlugin)this).Config.Bind<int>("Guard", "WorthsPerMinute", 15, "How many times one player may set a sell value in a minute before it is treated as proven. Was 6, which is a rate a very good angler might touch on a hot spot - and the strong tell here was never the rate, it is the same item being paid twice. This is the backstop, so it sits well clear of anything honest. 0 disables it.");
			LobbySize = ((BaseUnityPlugin)this).Config.Bind<int>("Lobby", "MaxPlayers", 0, "How many people the lobby holds. 0 leaves the game's own number alone. Raises both gates that decide it - FishNet's client cap and the Steam lobby's member limit - since whichever is lower is the real answer. The game was balanced around its own number, so nothing here can promise there are enough spawn points or boat seats; it only promises they can connect.");
			RpcsPerSecond = ((BaseUnityPlugin)this).Config.Bind<int>("Safety", "RpcsPerSecond", 300, "How many rpcs one client may send in a second before the rest of that second is dropped. This is the flood case: nothing malformed, just more than the lobby can process. Counted across ALL calls, since a flood spread over forty of them is still a flood. 0 disables it.");
			RuleStormCount = ((BaseUnityPlugin)this).Config.Bind<int>("Safety", "RuleStormCount", 25, "How many times one rule may fire inside RuleStormMinutes before it is switched off as broken. A cheat is blocked the first time, so a rule that keeps firing is describing itself rather than the lobby. 0 disables this.");
			RuleStormMinutes = ((BaseUnityPlugin)this).Config.Bind<float>("Safety", "RuleStormMinutes", 3f, "The window RuleStormCount is counted over, in minutes.");
			BreakerPlayers = ((BaseUnityPlugin)this).Config.Bind<int>("Safety", "BreakerPlayers", 3, "If this many DIFFERENT players are flagged with nothing proven, stand down to Dry Run - a bad rule is likelier than an outbreak. 0 disables.");
			BreakerMinutes = ((BaseUnityPlugin)this).Config.Bind<float>("Safety", "BreakerMinutes", 5f, "Window for the above.");
			RequireProofToRemove = ((BaseUnityPlugin)this).Config.Bind<bool>("Safety", "RequireProofToRemove", true, "Never remove anyone on heuristics alone - at least one Certain finding is required. Strongly recommended.");
			AppealTo = ((BaseUnityPlugin)this).Config.Bind<string>("Safety", "AppealTo", "", "Added to the kick message so a wrongly-removed player knows where to complain. e.g. a Discord invite.");
			_panic = ((BaseUnityPlugin)this).Config.Bind<KeyboardShortcut>("Keys", "Panic", new KeyboardShortcut((KeyCode)283, (KeyCode[])(object)new KeyCode[1] { (KeyCode)304 }), "Drop straight to Dry Run. For when it starts misfiring and you want it to stop NOW.");
			_toggleOverlay = ((BaseUnityPlugin)this).Config.Bind<KeyboardShortcut>("Keys", "ToggleOverlay", new KeyboardShortcut((KeyCode)282, Array.Empty<KeyCode>()), "Show or hide the status panel on the left.");
			_toggleHelp = ((BaseUnityPlugin)this).Config.Bind<KeyboardShortcut>("Keys", "ToggleHelp", new KeyboardShortcut((KeyCode)284, Array.Empty<KeyCode>()), "Show or hide the command list on the right.");
			SmiteFov = ((BaseUnityPlugin)this).Config.Bind<float>("Smite", "FovDegrees", 25f, "How far from the centre of your screen a player can be and still be the one you hit.");
			SmiteRange = ((BaseUnityPlugin)this).Config.Bind<float>("Smite", "Range", 200f, "Maximum distance you can smite from.");
			SmiteDamage = ((BaseUnityPlugin)this).Config.Bind<int>("Smite", "Damage", 99999, "Applied with a null attacker, so it works whether friendly fire is on or off.");
			SmiteLaunch = ((BaseUnityPlugin)this).Config.Bind<float>("Smite", "Launch", 30f, "Upward force on the blow.");
			SmiteCooldown = ((BaseUnityPlugin)this).Config.Bind<float>("Smite", "Cooldown", 0.4f, "Minimum gap between smites, so a held key does not fire every frame.");
			FlySpeed = ((BaseUnityPlugin)this).Config.Bind<float>("HostTools", "FlySpeed", 20f, "Fly speed for the host. Testing tool - the host is exempt from inspection, so this never flags you.");
			FlyBoost = ((BaseUnityPlugin)this).Config.Bind<float>("HostTools", "FlyBoost", 4f, "Multiplier while holding Shift.");
			_fly = ((BaseUnityPlugin)this).Config.Bind<KeyboardShortcut>("Keys", "Fly", new KeyboardShortcut((KeyCode)103, Array.Empty<KeyCode>()), "Host fly mode, for getting a look at what people are doing.");
			_islandNext = ((BaseUnityPlugin)this).Config.Bind<KeyboardShortcut>("Keys", "NextIsland", new KeyboardShortcut((KeyCode)46, Array.Empty<KeyCode>()), "Move the whole lobby to the next island.");
			_islandPrev = ((BaseUnityPlugin)this).Config.Bind<KeyboardShortcut>("Keys", "PrevIsland", new KeyboardShortcut((KeyCode)44, Array.Empty<KeyCode>()), "Move the whole lobby to the previous island.");
			_smite = ((BaseUnityPlugin)this).Config.Bind<KeyboardShortcut>("Keys", "Smite", new KeyboardShortcut((KeyCode)280, Array.Empty<KeyCode>()), "Kill whoever is in your crosshair.");
			_dashboard = ((BaseUnityPlugin)this).Config.Bind<KeyboardShortcut>("Keys", "Dashboard", new KeyboardShortcut((KeyCode)285, Array.Empty<KeyCode>()), "Open the point-and-click console. Unlocks the mouse while it is open.");
			_cycleMode = ((BaseUnityPlugin)this).Config.Bind<KeyboardShortcut>("Keys", "CycleMode", new KeyboardShortcut((KeyCode)283, Array.Empty<KeyCode>()), "");
		}

		private void ReportConfigDrift()
		{
			try
			{
				List<string> list = new List<string>();
				foreach (KeyValuePair<ConfigDefinition, ConfigEntryBase> item in ((BaseUnityPlugin)this).Config)
				{
					ConfigEntryBase value = item.Value;
					if (value != null)
					{
						object boxedValue;
						object defaultValue;
						try
						{
							boxedValue = value.BoxedValue;
							defaultValue = value.DefaultValue;
						}
						catch
						{
							continue;
						}
						if (boxedValue != null && defaultValue != null && !object.Equals(boxedValue, defaultValue) && !(item.Key.Section == "Keys"))
						{
							list.Add($"{item.Key.Section}/{item.Key.Key} = {boxedValue} (code says {defaultValue})");
						}
					}
				}
				if (list.Count == 0)
				{
					Log.LogInfo((object)"[Config] every setting matches the code default.");
					return;
				}
				Log.LogWarning((object)($"[Config] {list.Count} setting(s) differ from the code " + "default. The saved file wins, so a threshold changed in an update stays at your old value until you change it here:"));
				foreach (string item2 in list)
				{
					Log.LogWarning((object)("[Config]    " + item2));
				}
			}
			catch (Exception ex)
			{
				Log.LogWarning((object)("[Config] could not compare settings: " + ex.Message));
			}
		}

		private void ApplyPatches()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Expected O, but got Unknown
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Expected O, but got Unknown
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Expected O, but got Unknown
			//IL_022f: Unknown result type (might be due to invalid IL or missing references)
			//IL_023d: Expected O, but got Unknown
			//IL_0463: Unknown result type (might be due to invalid IL or missing references)
			//IL_0470: Expected O, but got Unknown
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Expected O, but got Unknown
			//IL_01c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d7: Expected O, but got Unknown
			//IL_0301: Unknown result type (might be due to invalid IL or missing references)
			//IL_031e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0329: Expected O, but got Unknown
			//IL_0329: Expected O, but got Unknown
			//IL_0113: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: Expected O, but got Unknown
			//IL_034d: Unknown result type (might be due to invalid IL or missing references)
			//IL_035b: Expected O, but got Unknown
			Harmony val = new Harmony("com.brade.fishwarden");
			Type type = typeof(Player).Assembly.GetType("Server");
			HarmonyMethod val2 = new HarmonyMethod(AccessTools.Method(typeof(Guard), "Reader_Pre", (Type[])null, (Type[])null));
			HarmonyMethod val3 = new HarmonyMethod(AccessTools.Method(typeof(Guard), "Reader_Post", (Type[])null, (Type[])null));
			int num = 0;
			foreach (Rpc item in Targets.All)
			{
				if (item.Reader == null || item.Logic == null)
				{
					continue;
				}
				try
				{
					val.Patch((MethodBase)item.Reader, val2, (HarmonyMethod)null, (HarmonyMethod)null, val3, (HarmonyMethod)null);
					val.Patch((MethodBase)item.Logic, new HarmonyMethod(AccessTools.Method(typeof(Guard), item.Prefix, (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
					if (item.Name == "BuyItem")
					{
						val.Patch((MethodBase)item.Logic, (HarmonyMethod)null, new HarmonyMethod(AccessTools.Method(typeof(Guard), "BuyItem_Post", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
					}
					num++;
				}
				catch (Exception ex)
				{
					Log.LogError((object)("[Fishwarden] could not guard " + item.Name + ": " + ex.Message));
				}
			}
			Log.LogInfo((object)$"[Fishwarden] {num} RPC guards attached.");
			try
			{
				MethodInfo methodInfo = Targets.Resolve(typeof(Player), "RpcLogic", "RPCTeleport");
				if (methodInfo != null)
				{
					val.Patch((MethodBase)methodInfo, new HarmonyMethod(AccessTools.Method(typeof(ClientGuard), "Teleport_Pre", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				}
			}
			catch (Exception ex2)
			{
				Log.LogError((object)("[Fishwarden] Anchor unavailable: " + ex2.Message));
			}
			try
			{
				MethodInfo methodInfo2 = Targets.Resolve(type, "RpcLogic", "SpawnPlayer");
				if (methodInfo2 != null)
				{
					val.Patch((MethodBase)methodInfo2, new HarmonyMethod(AccessTools.Method(typeof(Crash), "SpawnPlayer_Pre", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				}
				else
				{
					Log.LogError((object)"[Fishwarden] SpawnPlayer not found - the lobby-crash block is NOT active.");
				}
			}
			catch (Exception ex3)
			{
				Log.LogError((object)("[Fishwarden] lobby-crash block unavailable: " + ex3.Message));
			}
			try
			{
				Type type2 = typeof(Player).Assembly.GetTypes().FirstOrDefault((Type t) => t.GetMethods(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic).Any((MethodInfo m) => m.Name.StartsWith("RpcReader___ServerRelayFrame___")));
				if (type2 != null)
				{
					MethodInfo methodInfo3 = Targets.Resolve(type2, "RpcReader", "ServerRelayFrame");
					MethodInfo methodInfo4 = Targets.Resolve(type2, "RpcLogic", "ServerRelayFrame");
					if (methodInfo3 != null)
					{
						val.Patch((MethodBase)methodInfo3, new HarmonyMethod(AccessTools.Method(typeof(Guard), "Reader_Pre", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(AccessTools.Method(typeof(Guard), "Reader_Post", (Type[])null, (Type[])null)), (HarmonyMethod)null);
					}
					if (methodInfo4 != null)
					{
						val.Patch((MethodBase)methodInfo4, new HarmonyMethod(AccessTools.Method(typeof(VoiceGuard), "Relay_Pre", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
					}
					Log.LogInfo((object)("[Gambit] voice relay found on " + type2.Name + " - muting is lobby-wide."));
				}
				else
				{
					Log.LogWarning((object)"[Gambit] voice relay not found - muting will be text-only.");
				}
			}
			catch (Exception ex4)
			{
				Log.LogError((object)("[Gambit] voice mute unavailable: " + ex4.Message));
			}
			try
			{
				WheelGuard.Install(val);
			}
			catch (Exception ex5)
			{
				Log.LogError((object)("[Fishwarden] wheel guard unavailable: " + ex5.Message));
			}
			try
			{
				Sanity.Install(val, type);
			}
			catch (Exception ex6)
			{
				Log.LogError((object)("[Fishwarden] sanity filter unavailable: " + ex6.Message));
			}
			try
			{
				Trace.Install(val, type);
			}
			catch (Exception ex7)
			{
				Log.LogError((object)("[Fishwarden] trace unavailable: " + ex7.Message));
			}
			try
			{
				MethodInfo methodInfo5 = AccessTools.PropertyGetter(typeof(Player), "BlockInputs");
				if (methodInfo5 != null)
				{
					val.Patch((MethodBase)methodInfo5, (HarmonyMethod)null, new HarmonyMethod(AccessTools.Method(typeof(Dashboard), "BlockInputs_Post", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				}
			}
			catch (Exception ex8)
			{
				Log.LogError((object)("[Fishwarden] input lock unavailable: " + ex8.Message));
			}
			try
			{
				val.PatchAll(typeof(JoinFixPatches).Assembly);
			}
			catch (Exception ex9)
			{
				Log.LogError((object)("[Gambit] bug fixes unavailable: " + ex9.Message));
			}
			try
			{
				HostTools.Install(val);
			}
			catch (Exception ex10)
			{
				Log.LogError((object)("[Fishwarden] host tools unavailable: " + ex10.Message));
			}
			try
			{
				Cheats.Install(val);
			}
			catch (Exception ex11)
			{
				Log.LogError((object)("[Gambit] private tools unavailable: " + ex11.Message));
			}
			try
			{
				Kit.Install(val);
			}
			catch (Exception ex12)
			{
				Log.LogWarning((object)("[Kit] install: " + ex12.Message));
			}
			try
			{
				Commands.Install(val);
			}
			catch (Exception ex13)
			{
				Log.LogError((object)("[Fishwarden] chat commands unavailable: " + ex13.Message));
			}
			VerifyAttached();
		}

		private void FixedUpdate()
		{
			Cheats.Fixed();
		}

		private void Update()
		{
			//IL_014f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0154: 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_0188: 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_01a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c5: 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_01e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0202: Unknown result type (might be due to invalid IL or missing references)
			//IL_0207: Unknown result type (might be due to invalid IL or missing references)
			//IL_021b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0220: Unknown result type (might be due to invalid IL or missing references)
			//IL_023c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0241: Unknown result type (might be due to invalid IL or missing references)
			//IL_025d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0262: Unknown result type (might be due to invalid IL or missing references)
			if (!_sessionOpen && IsHosting)
			{
				_sessionOpen = true;
				try
				{
					Lobby.Widen();
				}
				catch (Exception ex)
				{
					Log.LogWarning((object)("[Lobby] could not resize: " + ex.Message));
				}
				Logbook.BeginSession();
				Rollback.BeginSession();
				Safety.BeginSession();
				Cases.Reset();
				Movement.Reset();
				Flight.Reset();
				Firing.Reset();
				Aim.Reset();
				Guard.ResetLimits();
				Trace.Reset();
				Catalogue.Invalidate();
				AutoTroll.Reset();
				Throttle.Reset();
				Summary.Reset();
				Log.LogInfo((object)("[Fishwarden] hosting - log open at " + Logbook.FilePath));
			}
			if (_sessionOpen && !IsHosting)
			{
				_sessionOpen = false;
			}
			Dashboard.Tick();
			Cheats.Tick();
			Kit.Tick();
			PlayerListGuard.Sweep();
			ClientGuard.Tick();
			ClientWatch.Tick();
			if (IsHosting)
			{
				Cases.Tick();
				Catalogue.Watch();
				Movement.Tick();
				Flight.Tick();
				Extras.TickChum();
				Extras.TickSkunk();
				Extras.TickCooler();
				Extras.TickButterfingers();
				Actions.TickFreeze();
				Troll.Tick();
				if (Time.realtimeSinceStartup >= _nextSweep)
				{
					_nextSweep = Time.realtimeSinceStartup + 2f;
					Bans.Sweep();
					Actions.EnforceLockdown();
				}
			}
			try
			{
				if (ChatManager.IsTyping || PauseManager.IsPaused)
				{
					return;
				}
			}
			catch
			{
			}
			KeyboardShortcut value = _panic.Value;
			if (((KeyboardShortcut)(ref value)).IsDown())
			{
				SetLevel(Level.Watch);
				Log.LogWarning((object)"[Fishwarden] PANIC - dropped to Dry Run. Nothing will be blocked or kicked.");
				Guard.Announce("[Fishwarden] stood down to watching only.");
				return;
			}
			value = _fly.Value;
			if (((KeyboardShortcut)(ref value)).IsDown())
			{
				Chat.Info(HostTools.ToggleFly());
			}
			value = _islandNext.Value;
			if (((KeyboardShortcut)(ref value)).IsDown())
			{
				Chat.Info(HostTools.Next(backwards: false));
			}
			value = _islandPrev.Value;
			if (((KeyboardShortcut)(ref value)).IsDown())
			{
				Chat.Info(HostTools.Next(backwards: true));
			}
			value = _smite.Value;
			if (((KeyboardShortcut)(ref value)).IsDown())
			{
				string text = Smite.Strike();
				if (text != null)
				{
					Chat.Hit(text);
				}
			}
			value = _dashboard.Value;
			if (((KeyboardShortcut)(ref value)).IsDown())
			{
				Dashboard.Toggle();
			}
			value = _toggleOverlay.Value;
			if (((KeyboardShortcut)(ref value)).IsDown())
			{
				Overlay.ShowStatus = !Overlay.ShowStatus;
			}
			value = _toggleHelp.Value;
			if (((KeyboardShortcut)(ref value)).IsDown())
			{
				Overlay.ShowHelp = !Overlay.ShowHelp;
			}
			value = _cycleMode.Value;
			if (((KeyboardShortcut)(ref value)).IsDown())
			{
				CycleLevel();
			}
		}

		public static void CycleLevel()
		{
			SetLevel((CurrentLevel != Level.Lockdown) ? (CurrentLevel + 1) : Level.Watch);
		}

		public static void SetLevel(Level l)
		{
			if (l > Level.Watch && Safety.Tripped)
			{
				Safety.Rearm();
			}
			CurrentLevel = l;
			Policy.Adopt(l);
			Log.LogInfo((object)("[Fishwarden] " + Policy.Explain(l)));
			if (!TackleCheck.Passed)
			{
				Log.LogWarning((object)"[Fishwarden] level set, but the guard is DISARMED - nothing is inspected.");
			}
		}

		private static void VerifyAttached()
		{
			int num = 0;
			int num2 = 0;
			int num3 = 0;
			foreach (Rpc item in Targets.All)
			{
				if (item.Logic == null)
				{
					continue;
				}
				Patches patchInfo = Harmony.GetPatchInfo((MethodBase)item.Logic);
				if (patchInfo != null && patchInfo.Prefixes != null && patchInfo.Prefixes.Any((Patch p) => p.owner == "com.brade.fishwarden"))
				{
					num++;
					continue;
				}
				num2++;
				if (item.Critical)
				{
					num3++;
				}
				Log.LogError((object)("[Fishwarden] " + item.Name + " did NOT attach - it is not being guarded."));
			}
			Armed = num;
			NotArmed = num2;
			if (num3 > 0)
			{
				TackleCheck.ForceDisarm(num3 + " critical guard(s) failed to attach");
				Log.LogError((object)"=============== FISHWARDEN DISARMED ===============");
				Log.LogError((object)("Only " + num + " of " + Targets.All.Count + " guards actually attached,"));
				Log.LogError((object)"and critical ones are among the failures. Refusing to");
				Log.LogError((object)"pretend this lobby is protected. See HarmonyX errors above.");
				Log.LogError((object)"===================================================");
			}
			else if (num2 > 0)
			{
				Log.LogWarning((object)("[Fishwarden] " + num + " guards attached, " + num2 + " failed - reduced cover."));
			}
			else
			{
				Log.LogInfo((object)("[Fishwarden] all " + num + " guards verified attached."));
			}
		}

		private void OnGUI()
		{
			Overlay.Draw();
			Dashboard.Draw();
		}
	}
	public enum Action
	{
		Log,
		Block,
		Remove
	}
	public enum Level
	{
		Watch,
		Block,
		Strict,
		Lockdown
	}
	internal static class Policy
	{
		public static Action Proven = Action.Block;

		public static Action Suspicious = Action.Log;

		public static void SetProven(Action a)
		{
			Proven = a;
			Save();
		}

		public static void SetSuspicious(Action a)
		{
			Suspicious = a;
			Save();
		}

		public static void Adopt(Level l)
		{
			Proven = Table(l, Confidence.Certain);
			Suspicious = Table(l, Confidence.Strong);
			Save();
		}

		public static bool Matches(Level l)
		{
			if (Proven == Table(l, Confidence.Certain))
			{
				return Suspicious == Table(l, Confidence.Strong);
			}
			return false;
		}

		public static string CurrentName()
		{
			foreach (Level value in Enum.GetValues(typeof(Level)))
			{
				if (Matches(value))
				{
					return Name(value);
				}
			}
			return "Custom";
		}

		public static void Load()
		{
			if (Plugin.ProvenCosts != null)
			{
				Proven = Plugin.ProvenCosts.Value;
				Suspicious = Plugin.SuspicionCosts.Value;
			}
		}

		private static void Save()
		{
			if (Plugin.ProvenCosts != null)
			{
				Plugin.ProvenCosts.Value = Proven;
				Plugin.SuspicionCosts.Value = Suspicious;
			}
		}

		public static Action For(Level level, Confidence c)
		{
			return c switch
			{
				Confidence.Certain => Proven, 
				Confidence.Strong => Suspicious, 
				_ => Action.Log, 
			};
		}

		public static Action Table(Level level, Confidence c)
		{
			switch (level)
			{
			case Level.Watch:
				return Action.Log;
			case Level.Block:
				if (c != Confidence.Certain)
				{
					return Action.Log;
				}
				return Action.Block;
			case Level.Strict:
				return c switch
				{
					Confidence.Certain => Action.Remove, 
					Confidence.Strong => Action.Block, 
					_ => Action.Log, 
				};
			case Level.Lockdown:
				return c switch
				{
					Confidence.Certain => Action.Remove, 
					Confidence.Strong => Action.Remove, 
					_ => Action.Log, 
				};
			default:
				return Action.Log;
			}
		}

		public static string Name(Level l)
		{
			return l switch
			{
				Level.Watch => "Watch", 
				Level.Block => "Block", 
				Level.Strict => "Strict", 
				Level.Lockdown => "Lockdown", 
				_ => l.ToString(), 
			};
		}

		public static string Explain(Level l)
		{
			return l switch
			{
				Level.Watch => "WATCHING - writing everything down, stopping nothing", 
				Level.Block => "BLOCKING - proven cheats do not work, nobody is removed", 
				Level.Strict => "STRICT - proven cheats get you removed, suspicious ones are blocked", 
				Level.Lockdown => "LOCKDOWN - proven and repeated suspicion both get you removed", 
				_ => Name(l), 
			};
		}

		public static string Grid(Level l)
		{
			return "proven: " + Proven.ToString().ToLower() + "   suspicious: " + Suspicious.ToString().ToLower() + "   hunch: log";
		}

		public static string Spell()
		{
			foreach (Level value in Enum.GetValues(typeof(Level)))
			{
				if (Matches(value))
				{
					return Explain(value);
				}
			}
			return "CUSTOM - proven cheats are " + Costs(Proven).ToLowerInvariant() + ", suspicious ones are " + Costs(Suspicious).ToLowerInvariant();
		}

		public static string Costs(Action a)
		{
			return a switch
			{
				Action.Log => "Watched", 
				Action.Block => "Blocked", 
				Action.Remove => "Removed", 
				_ => a.ToString(), 
			};
		}
	}
	internal static class Rules
	{
		private static readonly HashSet<string> _off = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

		private static readonly HashSet<string> _seen = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

		public static readonly string[] Catalogue = new string[57]
		{
			"crash-packet", "packet-flood", "bad-numbers", "runaway-physics", "auto-fire", "bait-not-owned", "bait-release-other", "bait-set-other", "boat-hijack", "bought-a-creature",
			"bought-unpriced", "catch-limit", "chat-impersonation", "chum", "clone-spawn", "creature-damage-above-weapon", "creature-damage-impossible", "creature-damage-spoof", "creature-hit-from-nowhere", "damage-above-weapon",
			"damage-impossible", "damage-spoof", "eat-as-other", "eat-toggle-other", "flight", "flying", "force-drop", "force-finish", "free-purchase", "hit-from-nowhere",
			"inventory-push", "inventory-take", "item-move", "lobby-crash", "no-reload", "noclip", "not-for-sale", "npc-take", "perfect-accuracy", "persistent-flight",
			"physics-grab", "pocket-unlock", "projectile-flood", "projectile-spoof", "purchase-other", "reload-other", "remote-detonate", "respawn-other", "self-revive", "shot-through-wall",
			"speed", "teleport-crash", "teleport-other", "teleport-self", "walking-on-water", "worth-inflation", "worth-nudge"
		};

		public static IEnumerable<string> Known => Catalogue.Concat(_seen).Concat(_off).Distinct<string>(StringComparer.OrdinalIgnoreCase)
			.OrderBy<string, string>((string x) => x, StringComparer.OrdinalIgnoreCase);

		public static IEnumerable<string> Disabled => _off.OrderBy((string x) => x);

		public static int DisabledCount => _off.Count;

		public static bool Enabled(string rule)
		{
			if (rule != null)
			{
				return !_off.Contains(rule);
			}
			return true;
		}

		public static void Note(string rule)
		{
			if (!string.IsNullOrWhiteSpace(rule))
			{
				_seen.Add(rule);
			}
		}

		public static bool Disable(string rule)
		{
			if (string.IsNullOrWhiteSpace(rule))
			{
				return false;
			}
			bool num = _off.Add(rule);
			if (num)
			{
				Save();
			}
			return num;
		}

		public static bool Enable(string rule)
		{
			if (string.IsNullOrWhiteSpace(rule))
			{
				return false;
			}
			bool num = _off.Remove(rule);
			if (num)
			{
				Save();
			}
			return num;
		}

		public static void Load()
		{
			_off.Clear();
			string text = ((Plugin.DisabledRules != null) ? Plugin.DisabledRules.Value : "");
			if (string.IsNullOrWhiteSpace(text))
			{
				return;
			}
			string[] array = text.Split(',');
			for (int i = 0; i < array.Length; i++)
			{
				string text2 = array[i].Trim();
				if (text2.Length > 0)
				{
					_off.Add(text2);
				}
			}
			if (_off.Count > 0)
			{
				Plugin.Log.LogWarning((object)("[Rules] switched off: " + string.Join(", ", _off)));
			}
		}

		private static void Save()
		{
			if (Plugin.DisabledRules != null)
			{
				Plugin.DisabledRules.Value = string.Join(",", _off);
			}
		}
	}
	internal static class Presets
	{
		public sealed class Preset
		{
			public string Name;

			public string What;

			public Level Level;

			public bool AutoRemove;

			public float Warmup;

			public int Breaker;
		}

		public static readonly Preset[] All = new Preset[3]
		{
			new Preset
			{
				Name = "Public lobby",
				What = "cheats do not work, nobody gets kicked by mistake",
				Level = Level.Block,
				AutoRemove = false,
				Warmup = 5f,
				Breaker = 3
			},
			new Preset
			{
				Name = "Friends only",
				What = "just watching - nothing is enforced",
				Level = Level.Watch,
				AutoRemove = false,
				Warmup = 0f,
				Breaker = 0
			},
			new Preset
			{
				Name = "Red team test",
				What = "everything on, removes immediately, no grace period",
				Level = Level.Strict,
				AutoRemove = true,
				Warmup = 0f,
				Breaker = 0
			}
		};

		public static string Apply(Preset p)
		{
			Plugin.SetLevel(p.Level);
			Plugin.AutoKick.Value = p.AutoRemove;
			Plugin.WarmupMinutes.Value = p.Warmup;
			Plugin.BreakerPlayers.Value = p.Breaker;
			return p.Name + ": " + Policy.Explain(p.Level) + (p.AutoRemove ? ", removing without asking" : ", removals wait for you") + ((p.Warmup > 0f) ? $", {p.Warmup:0} min warm-up" : ", no warm-up");
		}

		public static Preset Find(string name)
		{
			return All.FirstOrDefault((Preset p) => p.Name.StartsWith(name ?? "", StringComparison.OrdinalIgnoreCase)) ?? All.FirstOrDefault((Preset p) => p.Name.ToLower().Contains((name ?? "").ToLower()));
		}
	}
	internal static class Reach
	{
		public static bool LastWasMelee { get; private set; }

		public static float MaxReach(Player attacker)
		{
			LastWasMelee = false;
			if ((Object)(object)attacker == (Object)null)
			{
				return -1f;
			}
			try
			{
				Item val = (((Object)(object)attacker.Holding != (Object)null) ? attacker.Holding.HeldItem : null);
				if ((Object)(object)val != (Object)null && (Object)(object)val.Weapon != (Object)null)
				{
					float num = FloatField(val.Weapon, "_range");
					return (num > 0f) ? num : Plugin.MaxShotDistance.Value;
				}
				if ((Object)(object)val != (Object)null && (Object)(object)val.Melee != (Object)null)
				{
					LastWasMelee = true;
					float num2 = FloatField(val.Melee, "_range");
					return (num2 > 0f) ? num2 : Plugin.MaxMeleeDistance.Value;
				}
				if ((Object)(object)val != (Object)null && (Object)(object)val.FishingRod != (Object)null)
				{
					return -1f;
				}
				LastWasMelee = true;
				PlayerPunching punching = attacker.Punching;
				if ((Object)(object)punching != (Object)null)
				{
					float num3 = FloatField(punching, "_range");
					if (num3 > 0f)
					{
						return num3;
					}
				}
				return Plugin.MaxMeleeDistance.Value;
			}
			catch
			{
				return -1f;
			}
		}

		public static string Explain(Player attacker, Player victim, NetworkConnection conn)
		{
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: 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_00ca: 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_0125: 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_0143: Unknown result type (might be due to invalid IL or missing references)
			//IL_0152: 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_017b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0187: 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)
			//IL_0193: Unknown result type (might be due to invalid IL or missing references)
			//IL_019f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c2: 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)
			try
			{
				float num = MaxReach(attacker);
				bool lastWasMelee = LastWasMelee;
				string text = "fists";
				string text2 = "nothing";
				try
				{
					Item val = (((Object)(object)attacker != (Object)null && (Object)(object)attacker.Holding != (Object)null) ? attacker.Holding.HeldItem : null);
					if ((Object)(object)val != (Object)null)
					{
						text2 = (((Object)val).name ?? "?").Replace("(Clone)", "").Trim();
						text = (((Object)(object)val.Weapon != (Object)null) ? "weapon" : (((Object)(object)val.Melee != (Object)null) ? "melee" : (((Object)(object)val.FishingRod != (Object)null) ? "rod" : "inert item")));
					}
				}
				catch
				{
				}
				Vector3 val2 = Body.Of(attacker);
				Vector3 val3 = Body.Of(victim);
				float num2 = Aim.SinceLastShot(conn);
				return $"held {text2} ({text}), reach read {num:0.00} melee={lastWasMelee}, " + $"attacker ({val2.x:0.0},{val2.y:0.0},{val2.z:0.0}) victim ({val3.x:0.0},{val3.y:0.0},{val3.z:0.0}), " + $"flat {Vector3.Distance(new Vector3(val2.x, 0f, val2.z), new Vector3(val3.x, 0f, val3.z)):0.0}m " + $"vertical {Mathf.Abs(val2.y - val3.y):0.0}m, " + ((num2 < 0f) ? "never fired a shot" : $"last shot {num2:0.0}s ago");
			}
			catch (Exception ex)
			{
				return "could not explain: " + ex.Message;
			}
		}

		public static bool TooFar(Player attacker, Player victim, out float distance, out float allowed)
		{
			//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_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_0032: 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)
			distance = -1f;
			allowed = -1f;
			if ((Object)(object)attacker == (Object)null || (Object)(object)victim == (Object)null)
			{
				return false;
			}
			try
			{
				Vector3 val = Body.Of(attacker);
				Vector3 val2 = Body.Of(victim);
				distance = Vector3.Distance(val, val2);
			}
			catch
			{
				return false;
			}
			allowed = Allowance(attacker);
			if (allowed > 0f)
			{
				return distance > allowed;
			}
			return false;
		}

		private static float Allowance(Player attacker)
		{
			float num = MaxReach(attacker);
			if (num <= 0f)
			{
				return -1f;
			}
			float num2 = (LastWasMelee ? Plugin.MeleeReachSlack.Value : Plugin.ReachSlack.Value);
			return num * Mathf.Max(1f, Plugin.ReachTolerance.Value) + num2;
		}

		public static bool TooFarFromPoint(Player attacker, Vector3 point, out float distance, out float allowed)
		{
			//IL_001c: 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)
			distance = -1f;
			allowed = -1f;
			if ((Object)(object)attacker == (Object)null)
			{
				return false;
			}
			try
			{
				distance = Vector3.Distance(Body.Of(attacker), point);
			}
			catch
			{
				return false;
			}
			allowed = Allowance(attacker);
			if (allowed > 0f)
			{
				return distance > allowed;
			}
			return false;
		}

		private static float FloatField(object o, string name)
		{
			try
			{
				Traverse val = Traverse.Create(o).Field(name);
				if (val == null || !val.FieldExists())
				{
					return -1f;
				}
				return val.GetValue<float>();
			}
			catch
			{
				return -1f;
			}
		}
	}
	internal static class Response
	{
		internal enum Family
		{
			Attack,
			Economy,
			Guns,
			Conjuring,
			Travel,
			Others,
			Movement,
			Other
		}

		private static readonly Dictionary<string, Family> Of = new Dictionary<string, Family>(StringComparer.OrdinalIgnoreCase)
		{
			["teleport-crash"] = Family.Attack,
			["bad-numbers"] = Family.Attack,
			["lobby-crash"] = Family.Attack,
			["clone-spawn"] = Family.Attack,
			["crash-packet"] = Family.Attack,
			["packet-flood"] = Family.Attack,
			["worth-inflation"] = Family.Economy,
			["worth-nudge"] = Family.Economy,
			["free-purchase"] = Family.Economy,
			["not-for-sale"] = Family.Economy,
			["bought-a-creature"] = Family.Economy,
			["bought-unpriced"] = Family.Economy,
			["purchase-other"] = Family.Economy,
			["catch-limit"] = Family.Economy,
			["force-finish"] = Family.Economy,
			["projectile-spoof"] = Family.Guns,
			["remote-detonate"] = Family.Guns,
			["damage-spoof"] = Family.Guns,
			["creature-damage-spoof"] = Family.Guns,
			["chum"] = Family.Conjuring,
			["teleport-self"] = Family.Travel,
			["teleport-other"] = Family.Travel,
			["eat-as-other"] = Family.Others,
			["eat-toggle-other"] = Family.Others,
			["bait-set-other"] = Family.Others,
			["bait-release-other"] = Family.Others,
			["bait-not-owned"] = Family.Others,
			["reload-other"] = Family.Others,
			["respawn-other"] = Family.Others,
			["self-revive"] = Family.Others,
			["force-drop"] = Family.Others,
			["boat-hijack"] = Family.Others,
			["npc-take"] = Family.Others,
			["chat-impersonation"] = Family.Others,
			["inventory-push"] = Family.Others,
			["inventory-take"] = Family.Others,
			["item-move"] = Family.Others,
			["physics-grab"] = Family.Others,
			["pocket-unlock"] = Family.Others,
			["flying"] = Family.Movement,
			["flight"] = Family.Movement,
			["persistent-flight"] = Family.Movement,
			["noclip"] = Family.Movement,
			["walking-on-water"] = Family.Movement,
			["speed"] = Family.Movement,
			["projectile-flood"] = Family.Movement,
			["runaway-physics"] = Family.Movement,
			["no-reload"] = Family.Movement,
			["auto-fire"] = Family.Movement,
			["shot-through-wall"] = Family.Movement,
			["perfect-accuracy"] = Family.Movement,
			["hit-from-nowhere"] = Family.Movement,
			["creature-hit-from-nowhere"] = Family.Movement,
			["damage-impossible"] = Family.Movement,
			["damage-above-weapon"] = Family.Movement,
			["creature-damage-impossible"] = Family.Movement,
			["creature-damage-above-weapon"] = Family.Movement
		};

		private static readonly Dictionary<ulong, float> _lastAnswer = new Dictionary<ulong, float>();

		public static int Overridden => Count(Plugin.BlockOff) + Count(Plugin.TrollOn) + Count(Plugin.TrollOff);

		public static Family FamilyOf(string rule)
		{
			if (rule == null || !Of.TryGetValue(rule, out var value))
			{
				return Family.Other;
			}
			return value;
		}

		private static bool DefaultBlock(Family f)
		{
			return true;
		}

		private static bool DefaultTroll(Family f)
		{
			return f switch
			{
				Family.Attack => false, 
				Family.Movement => false, 
				Family.Other => false, 
				_ => true, 
			};
		}

		public static bool Blocks(string rule)
		{
			if (rule == null)
			{
				return true;
			}
			if (Listed(Plugin.BlockOff, rule))
			{
				return false;
			}
			return DefaultBlock(FamilyOf(rule));
		}

		public static bool Trolls(string rule)
		{
			if (rule == null)
			{
				return false;
			}
			if (Listed(Plugin.TrollOff, rule))
			{
				return false;
			}
			if (Listed(Plugin.TrollOn, rule))
			{
				return true;
			}
			return DefaultTroll(FamilyOf(rule));
		}

		public static string Toggle(string rule, bool troll)
		{
			if (!troll)
			{
				_ = Plugin.BlockOff;
			}
			else
			{
				_ = Plugin.TrollOn;
			}
			if (troll)
			{
				_ = Plugin.TrollOff;
			}
			if (troll)
			{
				bool flag = !Trolls(rule);
				Drop(Plugin.TrollOn, rule);
				Drop(Plugin.TrollOff, rule);
				if (flag != DefaultTroll(FamilyOf(rule)))
				{
					Add(flag ? Plugin.TrollOn : Plugin.TrollOff, rule);
				}
				if (!flag)
				{
					return rule + " no longer answers back.";
				}
				return rule + " now answers back.";
			}
			bool num = Blocks(rule);
			if (num)
			{
				Add(Plugin.BlockOff, rule);
			}
			else
			{
				Drop(Plugin.BlockOff, rule);
			}
			if (!num)
			{
				return rule + " is refused again.";
			}
			return rule + " is no longer refused - findings are recorded only.";
		}

		private static bool Listed(ConfigEntry<string> e, string rule)
		{
			if (e == null || string.IsNullOrEmpty(e.Value))
			{
				return false;
			}
			return e.Value.Split(',').Any((string x) => string.Equals(x.Trim(), rule, StringComparison.OrdinalIgnoreCase));
		}

		private static void Add(ConfigEntry<string> e, string rule)
		{
			if (e != null && !Listed(e, rule))
			{
				e.Value = (string.IsNullOrWhiteSpace(e.Value) ? rule : (e.Value + "," + rule));
			}
		}

		private static void Drop(ConfigEntry<string> e, string rule)
		{
			if (e != null && !string.IsNullOrEmpty(e.Value))
			{
				e.Value = string.Join(",", (from x in e.Value.Split(',')
					select x.Trim() into x
					where x.Length > 0 && !string.Equals(x, rule, StringComparison.OrdinalIgnoreCase)
					select x).ToArray());
			}
		}

		private static int Count(ConfigEntry<string> e)
		{
			if (e != null && !string.IsNullOrWhiteSpace(e.Value))
			{
				return e.Value.Split(',').Count((string x) => x.Trim().Length > 0);
			}
			return 0;
		}

		public static void Answer(NetworkConnection conn, string rule)
		{
			if (!Plugin.IsHosting || rule == null || !Trolls(rule))
			{
				return;
			}
			Player val;
			try
			{
				if (Sender.IsTrusted(conn))
				{
					return;
				}
				val = Sender.PlayerFor(conn);
				if ((Object)(object)val == (Object)null)
				{
					return;
				}
			}
			catch
			{
				return;
			}
			ulong steamID;
			try
			{
				steamID = val.SteamID;
			}
			catch
			{
				return;
			}
			float realtimeSinceStartup = Time.realtimeSinceStartup;
			if (_lastAnswer.TryGetValue(steamID, out var value) && realtimeSinceStartup - value < Plugin.AnswerCooldown.Value)
			{
				return;
			}
			_lastAnswer[steamID] = realtimeSinceStartup;
			string text = Fire(val, steamID, rule);
			if (text == null)
			{
				return;
			}
			Plugin.Log.LogInfo((object)("[Response] " + val.SteamName + " · " + rule + " · " + text));
			try
			{
				string msg = Hazing.ShameFor(rule, (int)(steamID % 997));
				Chat.AsPlayer(val, msg);
			}
			catch
			{
			}
		}

		private static string Fire(Player p, ulong key, string rule)
		{
			try
			{
				switch (FamilyOf(rule))
				{
				case Family.Guns:
					return Extras.Blowback(p);
				case Family.Conjuring:
					Actions.Purge(p);
					return Extras.Butterfingers(p);
				case Family.Travel:
					return Extras.Locker(p);
				case Family.Others:
					return Actions.IsFrozen(key) ? null : Actions.ToggleFreeze(p);
				case Family.Economy:
					return Extras.IsSkunked(key) ? null : Extras.Skunk(p);
				default:
					return null;
				}
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("[Response] could not answer " + rule + ": " + ex.Message));
				return null;
			}
		}
	}
	internal static class Rollback
	{
		private sealed class Damage
		{
			public readonly List<Item> Spawned = new List<Item>();

			public readonly List<Item> Inflated = new List<Item>();

			public readonly List<Player> Killed = new List<Player>();

			public int MoneyAtFirstOffence = -1;
		}

		private static readonly Dictionary<ulong, Damage> _byOffender = new Dictionary<ulong, Damage>();

		private static int _sessionMoney = -1;

		private static Damage For(ulong key)
		{
			if (!_byOffender.TryGetValue(key, out var value))
			{
				value = new Damage
				{
					MoneyAtFirstOffence = CurrentMoney()
				};
				_byOffender[key] = value;
			}
			return value;
		}

		public static bool HasDamage(ulong key)
		{
			if (_byOffender.TryGetValue(key, out var value))
			{
				if (value.Spawned.Count <= 0 && value.Inflated.Count <= 0)
				{
					return value.Killed.Count > 0;
				}
				return true;
			}
			return false;
		}

		public static void NoteSpawn(ulong key, Item item)
		{
			if (!((Object)(object)item == (Object)null))
			{
				For(key).Spawned.Add(item);
			}
		}

		public static void NoteInflated(ulong key, Item item)
		{
			if (!((Object)(object)item == (Object)null))
			{
				For(key).Inflated.Add(item);
			}
		}

		public static void NoteKill(ulong key, Player victim)
		{
			if (!((Object)(object)victim == (Object)null))
			{
				For(key).Killed.Add(victim);
			}
		}

		public static void NoteOffence(ulong key)
		{
			For(key);
		}

		public static string Gut(ulong key)
		{
			if (!_byOffender.TryGetValue(key, out var value))
			{
				return Logbook.Name(key) + " has nothing to undo - everything they tried was blocked.";
			}
			int num = 0;
			int num2 = 0;
			int num3 = 0;
			bool flag = false;
			foreach (Item item in value.Spawned.Where((Item i) => (Object)(object)i != (Object)null))
			{
				try
				{
					item.DestroyItem((byte)4, byte.MaxValue);
					num++;
				}
				catch (Exception ex)
				{
					Plugin.Log.LogWarning((object)("[Gutted] despawn failed: " + ex.Message));
				}
			}
			foreach (Item item2 in value.Inflated.Where((Item i) => (Object)(object)i != (Object)null))
			{
				try
				{
					Server.Instance.SetItemMultiplier(item2, 1f);
					num2++;
				}
				catch (Exception ex2)
				{
					Plugin.Log.LogWarning((object)("[Gutted] multiplier reset failed: " + ex2.Message));
				}
			}
			foreach (Player item3 in value.Killed.Where((Player p) => (Object)(object)p != (Object)null))
			{
				try
				{
					DeadPlayer val = (((Object)(object)item3.Dying != (Object)null) ? item3.Dying.DeadPlayer : null);
					if ((Object)(object)val != (Object)null && (Object)(object)item3.Vitals != (Object)null && item3.Vitals.Health <= 0)
					{
						Server.Instance.ResurrectPlayer(item3, val);
						num3++;
					}
				}
				catch (Exception ex3)
				{
					Plugin.Log.LogWarning((object)("[Gutted] resurrect failed: " + ex3.Message));
				}
			}
			if (value.MoneyAtFirstOffence >= 0 && CurrentMoney() > value.MoneyAtFirstOffence)
			{
				flag = SetMoney(value.MoneyAtFirstOffence);
			}
			_byOffender.Remove(key);
			List<string> list = new List<string>();
			if (num > 0)
			{
				list.Add(string.Format("{0} spawned item{1} removed", num, (num == 1) ? "" : "s"));
			}
			if (num2 > 0)
			{
				list.Add(string.Format("{0} inflated value{1} reset", num2, (num2 == 1) ? "" : "s"));
			}
			if (num3 > 0)
			{
				list.Add(string.Format("{0} player{1} revived", num3, (num3 == 1) ? "" : "s"));
			}
			if (flag)
			{
				list.Add($"money restored to {value.MoneyAtFirstOffence}");
			}
			if (list.Count != 0)
			{
				return "Undid " + Logbook.Name(key) + ": " + string.Join(", ", list) + ".";
			}
			return Logbook.Name(key) + " has nothing to undo - everything they tried was blocked, so none of it happened.";
		}

		public static void BeginSession()
		{
			_sessionMoney = CurrentMoney();
			_byOffender.Clear();
		}

		public static string RestoreWorld()
		{
			if (!Plugin.IsHosting)
			{
				return "Only the host can do that.";
			}
			List<ulong> list = _byOffender.Keys.ToList();
			int num = 0;
			int num2 = 0;
			int num3 = 0;
			foreach (ulong item in list)
			{
				if (!_byOffender.TryGetValue(item, out var value))
				{
					continue;
				}
				foreach (Item item2 in value.Spawned.Where((Item i) => (Object)(object)i != (Object)null))
				{
					try
					{
						item2.DestroyItem((byte)4, byte.MaxValue);
						num++;
					}
					catch
					{
					}
				}
				foreach (Item item3 in value.Inflated.Where((Item i) => (Object)(object)i != (Object)null))
				{
					try
					{
						Server.Instance.SetItemMultiplier(item3, 1f);
						num2++;
					}
					catch
					{
					}
				}
				foreach (Player item4 in value.Killed.Where((Player p) => (Object)(object)p != (Object)null))
				{
					try
					{
						DeadPlayer val = (((Object)(object)item4.Dying != (Object)null) ? item4.Dying.DeadPlayer : null);
						if ((Object)(object)val != (Object)null && (Object)(object)item4.Vitals != (Object)null && item4.Vitals.Health <= 0)
						{
							Server.Instance.ResurrectPlayer(item4, val);
							num3++;
						}
					}
					catch
					{
					}
				}
			}
			_byOffender.Clear();
			bool flag = false;
			if (_sessionMoney >= 0 && CurrentMoney() > _sessionMoney)
			{
				flag = SetMoney(_sessionMoney);
			}
			List<string> list2 = new List<string>();
			if (num > 0)
			{
				list2.Add($"{num} spawned item(s) removed");
			}
			if (num2 > 0)
			{
				list2.Add($"{num2} inflated value(s) reset");
			}
			if (num3 > 0)
			{
				list2.Add($"{num3} player(s) revived");
			}
			if (flag)
			{
				list2.Add($"money back to {_sessionMoney}");
			}
			if (list2.Count != 0)
			{
				return "Session restored: " + string.Join(", ", list2) + ".";
			}
			return "Nothing to put back - nobody got anything past the guard.";
		}

		public static string GutAll()
		{
			List<ulong> list = _byOffender.Keys.ToList();
			if (list.Count == 0)
			{
				return "Nothing recorded this session.";
			}
			return string.Join("  ", list.Select(Gut));
		}

		public static void Clear(ulong key)
		{
			_byOffender.Remove(key);
		}

		private static int CurrentMoney()
		{
			try
			{
				return MoneyManager.Money;
			}
			catch
			{
				return -1;
			}
		}

		private static bool SetMoney(int value)
		{
			try
			{
				MoneyManager instance = MoneyManager.Instance;
				if ((Object)(object)instance == (Object)null)
				{
					return false;
				}
				instance._money.Value = Mathf.Max(0, value);
				return true;
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("[Gutted] money restore failed: " + ex.Message));
				return false;
			}
		}
	}
	internal static class Safety
	{
		private static float _sessionStart = -1f;

		private static readonly Dictionary<ulong, float> _firstFlag = new Dictionary<ulong, float>();

		private static readonly HashSet<ulong> _proven = new HashSet<ulong>();

		private static bool _tripped;

		private static readonly Dictionary<string, float> _ruleSince = new Dictionary<string, float>();

		private static readonly Dictionary<string, int> _ruleCount = new Dictionary<string, int>();

		public static bool Tripped => _tripped;

		public static float WarmupRemaining
		{
			get
			{
				if (_sessionStart < 0f)
				{
					return 0f;
				}
				float num = Plugin.WarmupMinutes.Value * 60f - (Time.realtimeSinceStartup - _sessionStart);
				return Mathf.Max(0f, num);
			}
		}

		public static bool InWarmup => WarmupRemaining > 0.01f;

		public static bool HoldFire
		{
			get
			{
				if (!_tripped)
				{
					if (InWarmup)
					{
						return Plugin.WarmupMinutes.Value > 0f;
					}
					return false;
				}
				return true;
			}
		}

		public static void BeginSession()
		{
			_sessionStart = Time.realtimeSinceStartup;
			_firstFlag.Clear();
			_proven.Clear();
			_ruleSince.Clear();
			_ruleCount.Clear();
			_tripped = false;
		}

		private static void Storm(string rule)
		{
			if (string.IsNullOrEmpty(rule) || Plugin.RuleStormCount.Value <= 0 || !Rules.Enabled(rule))
			{
				return;
			}
			float realtimeSinceStartup = Time.realtimeSinceStartup;
			float num = Plugin.RuleStormMinutes.Value * 60f;
			if (!_ruleSince.TryGetValue(rule, out var value) || realtimeSinceStartup - value > num)
			{
				_ruleSince[rule] = realtimeSinceStartup;
				_ruleCount[rule] = 1;
				return;
			}
			_ruleCount.TryGetValue(rule, out var value2);
			value2++;
			_ruleCount[rule] = value2;
			if (value2 < Plugin.RuleStormCount.Value)
			{
				return;
			}
			Rules.Disable(rule);
			_ruleCount[rule] = 0;
			Plugin.Log.LogError((object)"=============== RULE SWITCHED OFF ===============");
			Plugin.Log.LogError((object)($"'{rule}' fired {value2} times in under " + $"{Plugin.RuleStormMinutes.Value:0} minute(s). No cheat needs to " + "trip the same rule that often - it is blocked the first time - so the rule is wrong, not the lobby."));
			Plugin.Log.LogError((object)"It is switched off. Everything else keeps working. Turn it back on in the console under THE GUARD, Every check.");
			Plugin.Log.LogError((object)"================================================");
			try
			{
				Guard.Announce("[Fishwarden] '" + rule + "' was misfiring and has been switched off.");
			}
			catch
			{
			}
		}

		public static void Saw(ulong key, Confidence c, string rule = null)
		{
			Storm(rule);
			if (c == Confidence.Certain)
			{
				_proven.Add(key);
			}
			float now = Time.realtimeSinceStartup;
			if (!_firstFlag.ContainsKey(key))
			{
				_firstFlag[key] = now;
			}
			if (!_tripped && Plugin.BreakerPlayers.Value > 0)
			{
				float window = Plugin.BreakerMinutes.Value * 60f;
				_firstFlag.Count((KeyValuePair<ulong, float> kv) => now - kv.Value <= window);
				int num = _firstFlag.Count((KeyValuePair<ulong, float> kv) => now - kv.Value <= window && !_proven.Contains(kv.Key));
				if (num >= Plugin.BreakerPlayers.Value)
				{
					_tripped = true;
					Plugin.SetLevel(Level.Watch);
					Plugin.Log.LogError((object)"=============== FISHWARDEN STOOD DOWN ===============");
					Plugin.Log.LogError((object)($"{num} different players were flagged within " + $"{Plugin.BreakerMinutes.Value} minutes without a single proven finding."));
					Plugin.Log.LogError((object)"That is far more likely to be a bad rule than an outbreak,");
					Plugin.Log.LogError((object)"so enforcement is off and the guard is only watching now.");
					Plugin.Log.LogError((object)"Check the logbook, then /level block again if it looks right.");
					Plugin.Log.LogError((object)"=====================================================");
					Guard.Announce("[Fishwarden] stood down - too many players flagged too fast. That is probably my fault, not yours. Watching only.");
				}
			}
		}

		public static bool MayRemove(ulong key)
		{
			if (!Plugin.RequireProofToRemove.Value)
			{
				return true;
			}
			return _proven.Contains(key);
		}

		public static void Forget(ulong key)
		{
			_firstFlag.Remove(key);
			_proven.Remove(key);
		}

		public static void Rearm()
		{
			_tripped = false;
			_firstFlag.Clear();
		}

		public static string Status()
		{
			if (_tripped)
			{
				return "STOOD DOWN - watching only, pick a level again to re-arm";
			}
			if (InWarmup)
			{
				return $"warm-up {WarmupRemaining:0}s - proven cheats still blocked, guesses only watched";
			}
			return null;
		}
	}
	internal static class Sanity
	{
		private const float Bound = 1000000f;

		private const int MaxText = 4096;

		private const int MaxItems = 4096;

		private static float _nextBark;

		private static int _swallowed;

		private static readonly Dictionary<NetworkConnection, int> _rate = new Dictionary<NetworkConnection, int>();

		private static float _rateWindow;

		private static readonly Dictionary<NetworkConnection, float> _saidAt = new Dictionary<NetworkConnection, float>();

		public static int Blocked { get; private set; }

		public static bool Check(object[] __args, MethodBase __originalMethod)
		{
			if (__args == null)
			{
				return true;
			}
			try
			{
				if (Flooding(__args, __originalMethod))
				{
					return false;
				}
				for (int i = 0; i < __args.Length; i++)
				{
					string text = Reason(__args[i]);
					if (text != null)
					{
						Refuse(__originalMethod, i, text, __args);
						return false;
					}
				}
			}
			catch
			{
			}
			return true;
		}

		private static bool Flooding(object[] args, MethodBase method)
		{
			int num = ((Plugin.RpcsPerSecond != null) ? Plugin.RpcsPerSecond.Value : 0);
			if (num <= 0)
			{
				return false;
			}
			NetworkConnection val = null;
			foreach (object obj in args)
			{
				NetworkConnection val2 = (NetworkConnection)((obj is NetworkConnection) ? obj : null);
				if (val2 != null)
				{
					val = val2;
					break;
				}
			}
			if (val == (NetworkConnection)null)
			{
				val = Sender.Current;
			}
			if (val == (NetworkConnection)null)
			{
				return false;
			}
			if (Sender.IsTrusted(val))
			{
				return false;
			}
			float realtimeSinceStartup = Time.realtimeSinceStartup;
			if (realtimeSinceStartup >= _rateWindow)
			{
				_rateWindow = realtimeSinceStartup + 1f;
				_rate.Clear();
			}
			_rate.TryGetValue(val, out var value);
			value++;
			_rate[val] = value;
			if (value != num)
			{
				return value > num;
			}
			Blocked++;
			Plugin.Log.LogError((object)($"[Sanity] {Sender.NameOf(val)} is sending more than {num} " + "rpcs a second - dropping the rest of this second. Nothing malformed, just more than the lobby can process."));
			try
			{
				if (Plugin.IsHosting)
				{
					Guard.Report(val, (method != null) ? Clean(method.Name) : "an RPC", Verdict.Certain("packet-flood", $"sent over {num} rpcs in one second - no client plays this fast"));
				}
			}
			catch
			{
			}
			return true;
		}

		private static string Reason(object arg)
		{
			//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_0053: 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_00bd: 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_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: 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_00f0: 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_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: 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)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			if (arg == null)
			{
				return null;
			}
			if (arg is float f)
			{
				if (!Broken(f))
				{
					return null;
				}
				return "a float that is not a number";
			}
			if (arg is double num)
			{
				if (!Broken((float)num))
				{
					return null;
				}
				return "a double that is not a number";
			}
			if (arg is Vector3 val)
			{
				if (!Broken(val.x) && !Broken(val.y) && !Broken(val.z))
				{
					if (!Outside(val.x) && !Outside(val.y) && !Outside(val.z))
					{
						return null;
					}
					return "a position outside the world";
				}
				return "a position that is not a number";
			}
			if (arg is Vector2 val2)
			{
				if (!Broken(val2.x) && !Broken(val2.y))
				{
					return null;
				}
				return "a vector that is not a number";
			}
			if (arg is Quaternion val3)
			{
				if (!Broken(val3.x) && !Broken(val3.y) && !Broken(val3.z) && !Broken(val3.w))
				{
					return null;
				}
				return "a rotation that is not a number";
			}
			if (arg is string text)
			{
				if (text.Length <= 4096)
				{
					return null;
				}
				return $"a string of {text.Length} characters";
			}
			if (arg is ICollection collection)
			{
				if (collection.Count <= 4096)
				{
					return null;
				}
				return $"a list of {collection.Count} entries";
			}
			return null;
		}

		private static bool IsRelay(string call)
		{
			if (string.IsNullOrEmpty(call))
			{
				return false;
			}
			string[] chatty = Trace.Chatty;
			for (int i = 0; i < chatty.Length; i++)
			{
				if (string.Equals(chatty[i], call, StringComparison.Ordinal))
				{
					return true;
				}
			}
			return false;
		}

		private static bool Sayable(NetworkConnection conn)
		{
			float realtimeSinceStartup = Time.realtimeSinceStartup;
			if (_saidAt.TryGetValue(conn, out var value) && realtimeSinceStartup - value < 1f)
			{
				return false;
			}
			_saidAt[conn] = realtimeSinceStartup;
			return true;
		}

		private static bool Broken(float f)
		{
			if (!float.IsNaN(f))
			{
				return float.IsInfinity(f);
			}
			return true;
		}

		private static bool Outside(float f)
		{
			return Mathf.Abs(f) > 1000000f;
		}

		private static void Refuse(MethodBase method, int index, string why, object[] args)
		{
			Blocked++;
			NetworkConnection val = Sender.Current;
			if (val == (NetworkConnection)null && args != null)
			{
				foreach (object obj in args)
				{
					NetworkConnection val2 = (NetworkConnection)((obj is NetworkConnection) ? obj : null);
					if (val2 != null)
					{
						val = val2;
						break;
					}
				}
			}
			string text = ((val != (NetworkConnection)null) ? Sender.NameOf(val) : "somebody");
			string text2 = ((method != null) ? Clean(method.Name) : "an RPC");
			float realtimeSinceStartup = Time.realtimeSinceStartup;
			if (realtimeSinceStartup >= _nextBark)
			{
				_nextBark = realtimeSinceStartup + 1f;
				Plugin.Log.LogError((object)($"[Sanity] refused {text2} from {text}: argument {index} is {why}." + ((_swallowed > 0) ? $" (+{_swallowed} more in the last second)" : "")));
				_swallowed = 0;
			}
			else
			{
				_swallowed++;
			}
			try
			{
				if (val != (NetworkConnection)null && Plugin.IsHosting && !Sender.IsTrusted(val) && Sayable(val))
				{
					bool flag = IsRelay(text2);
					Guard.Report(val, text2, flag ? Verdict.Certain("runaway-physics", "relayed " + why + " through " + text2 + " - an object whose physics has run away, which the packet drop already contains") : Verdict.Certain("bad-numbers", "sent " + why + " to " + text2 + " - values no client can produce, and which crash whoever they are applied to"));
				}
			}
			catch
			{
			}
		}

		public static Exception Caught(Exception __exception, MethodBase __originalMethod, object[] __args)
		{
			if (__exception == null)
			{
				return null;
			}
			Blocked++;
			string text = ((__originalMethod != null) ? Clean(__originalMethod.Name) : "an RPC");
			NetworkConnection val = Sender.Current;
			if (val == (NetworkConnection)null && __args != null)
			{
				foreach (object obj in __args)
				{
					NetworkConnection val2 = (NetworkConnection)((obj is NetworkConnection) ? obj : null);
					if (val2 != null)
					{
						val = val2;
						break;
					}
				}
			}
			string text2 = ((val != (NetworkConnection)null) ? Sender.NameOf(val) : "somebody");
			float realtimeSinceStartup = Time.realtimeSinceStartup;
			if (realtimeSinceStartup >= _nextBark)
			{
				_nextBark = realtimeSinceStartup + 1f;
				Plugin.Log.LogError((object)("[Sanity] " + text + " from " + text2 + " threw " + __exception.GetType().Name + " - packet dropped, lobby kept. " + __exception.Message + ((_swallowed > 0) ? $" (+{_swallowed} more in the last second)" : "")));
				_swallowed = 0;
			}
			else
			{
				_swallowed++;
			}
			try
			{
				if (val != (NetworkConnection)null && Plugin.IsHosting && !Sender.IsTrusted(val) && Sayable(val))
				{
					Guard.Report(val, text, Verdict.Certain("crash-packet", "sent something that made " + text + " throw " + __exception.GetType().Name + " - a packet the game cannot process"));
				}
			}
			catch
			{
			}
			return null;
		}

		private static string Clean(string name)
		{
			if (string.IsNullOrEmpty(name))
			{
				return "an RPC";
			}
			int num = name.IndexOf("___", StringComparison.Ordinal);
			if (num < 0)
			{
				return name;
			}
			string text = name.Substring(num + 3);
			int num2 = text.IndexOf("___", StringComparison.Ordinal);
			if (num2 <= 0)
			{
				return text;
			}
			return text.Substring(0, num2);
		}

		public static void Install(Harmony h, Type server)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Expected O, but got Unknown
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Expected O, but got Unknown
			HarmonyMethod val = new HarmonyMethod(AccessTools.Method(typeof(Sanity), "Check", (Type[])null, (Type[])null));
			HarmonyMethod val2 = new HarmonyMethod(AccessTools.Method(typeof(Sanity), "Caught", (Type[])null, (Type[])null));
			int num = 0;
			int num2 = 0;
			List<MethodInfo> list = (from m in server.GetMethods(BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic)
				where m.Name.StartsWith("RpcLogic___", StringComparison.Ordinal)
				select m).ToList();
			foreach (MethodInfo item in list)
			{
				if (!(item == null))
				{
					try
					{
						h.Patch((MethodBase)item, val, (HarmonyMethod)null, (HarmonyMethod)null, val2, (HarmonyMethod)null);
						num++;
					}
					catch (Exception ex)
					{
						num2++;
						Plugin.Log.LogWarning((object)("[Sanity] could not cover " + item.Name + ": " + ex.Message));
					}
				}
			}
			Plugin.Log.LogInfo((object)($"[Sanity] {num} of {list.Count} RPC(s) covered - no NaN, no " + "infinity, nothing past a million metres, no giant strings or lists, and anything that throws anyway kills the packet instead of the lobby." + ((num2 > 0) ? $" {num2} could not be covered." : "")));
		}
	}
	internal static class SelfTest
	{
		private sealed class Result
		{
			public string Name;

			public bool Pass;

			public string Detail;
		}

		private static readonly List<Result> _results = new List<Result>();

		private static void Check(string name, bool pass, string detail = null)
		{
			_results.Add(new Result
			{
				Name = name,
				Pass = pass,
				Detail = detail
			});
		}

		public static List<string> Run()
		{
			_results.Clear();
			Attachment();
			PolicyMatrix();
			DamageCeiling();
			ThrottleBehaviour();
			WarmupScope();
			AdminExempt();
			HazingCoverage();
			CatalogueState();
			RuleWiring();
			ResponseMatrix();
			SanityValues();
			AttackTiers();
			int num = _results.Count((Result r) => r.Pass);
			int num2 = _results.Count - num;
			List<string> list = new List<string> { $"Self-test: {num} passed, {num2} failed" };
			foreach (Result item in _results.Where((Result r) => !r.Pass))
			{
				list.Add("  FAIL  " + item.Name + "  -  " + item.Detail);
			}
			if (num2 == 0)
			{
				list.Add("  everything the guard depends on is behaving.");
			}
			else
			{
				list.Add("  do NOT trust this lobby until the failures above are fixed.");
			}
			foreach (string item2 in list)
			{
				Plugin.Log.LogInfo((object)("[SelfTest] " + item2));
			}
			return list;
		}

		private static void Attachment()
		{
			Check("guard armed", TackleCheck.Passed, "TackleCheck did not pass");
			Check("all rules attached", Plugin.NotArmed == 0, $"{Plugin.NotArmed} rule(s) resolved but failed to attach");
			Check("rule count sane", Plugin.Armed >= Targets.All.Count - 2, $"only {Plugin.Armed} of {Targets.All.Count} attached");
		}

		private static void PolicyMatrix()
		{
			foreach (Level value in Enum.GetValues(typeof(Level)))
			{
				Check("hunches inert at " + Policy.Name(value), Policy.For(value, Confidence.Contextual) == Action.Log, "a contextual finding would be acted on");
			}
			Check("Watch acts on nothing", Policy.For(Level.Watch, Confidence.Certain) == Action.Log, "Watch would act on a proven finding");
			Check("Block stops proven", Policy.For(Level.Block, Confidence.Certain) == Action.Block, "Block does not stop a proven finding");
			Check("Block removes nobody", Policy.For(Level.Block, Confidence.Certain) != Action.Remove, "Block would remove somebody");
			Check("Strict stops suspicion", Policy.For(Level.Strict, Confidence.Strong) != Action.Log, "Strict ignores a strong finding");
			Check("Lockdown removes on suspicion", Policy.For(Level.Lockdown, Confidence.Strong) == Action.Remove, "Lockdown does not remove on a strong finding");
		}

		private static void DamageCeiling()
		{
			Check("damage floor below player health", Plugin.MinimumDamageCeiling.Value < 100, $"floor is {Plugin.MinimumDamageCeiling.Value}, players have {100} - " + "anything up to the floor would one-shot and pass");
			Check("absolute cap above real weapons", Plugin.MaxPlausibleDamage.Value > 800, $"cap is {Plugin.MaxPlausibleDamage.Value}; an upgraded sniper reaches ~750 and would be flagged");
			Check("tolerance sane", Plugin.DamageTolerance.Value >= 1f && Plugin.DamageTolerance.Value <= 4f, $"tolerance {Plugin.DamageTolerance.Value} is outside a sensible range");
		}

		private static void ThrottleBehaviour()
		{
			Throttle.Reset();
			Verdict v = Verdict.Certain("selftest", "synthetic");
			int num = 0;
			for (int i = 0; i < 500; i++)
			{
				if (Throttle.ShouldReport(999999uL, "self-test", v))
				{
					num++;
				}
			}
			Check("burst is throttled", num <= 3, $"{num} of 500 identical findings would have been reported and announced");
			Check("first is always reported", num >= 1, "a burst would be entirely silent");
			Check("suppressed repeats counted", Throttle.TotalSuppressed > 400, $"only {Throttle.TotalSuppressed} counted as suppressed");
			Throttle.Reset();
		}

		private static void WarmupScope()
		{
			Check("warm-up does not shield proof", pass: true, "");
		}

		private static void HazingCoverage()
		{
			List<string> list = new List<string>();
			foreach (string item in Summary.KnownRules())
			{
				if (!Hazing.Reactions.ContainsKey(item))
				{
					list.Add(item);
				}
			}
			Check("every rule has a taunt", list.Count == 0, "no hazing line for: " + string.Join(", ", list));
		}

		private static void AdminExempt()
		{
			Player localPlayer = Player.LocalPlayer;
			NetworkConnection val = (((Object)(object)localPlayer != (Object)null) ? ((NetworkBehaviour)localPlayer).Owner : null);
			Check("host is exempt", val == (NetworkConnection)null || Sender.IsHost(val), "the host's own connection is not recognised - they would be flagged for their own tools");
			Check("null sender is trusted", Sender.IsTrusted(null), "a packet with no connection would be inspected");
		}

		private static void CatalogueState()
		{
			Check("shop catalogue readable", Catalogue.Usable, "shop stands could not be read, so 'not-for-sale' cannot fire. Fine before an island loads; a problem once you are in a lobby.");
		}

		private static void RuleWiring()
		{
			List<string> list = (from t in Targets.All
				where t.Logic == null
				select t.Name).ToList();
			Check("every rule has a target", list.Count == 0, "no method found for: " + string.Join(", ", list));
			int disabledCount = Rules.DisabledCount;
			Check("no rules switched off", disabledCount == 0, string.Format("{0} rule(s) disabled: {1} - intentional?", disabledCount, string.Join(", ", Rules.Disabled)));
		}

		public static List<string> Stress(int count)
		{
			count = Math.Max(100, Math.Min(count, 200000));
			Throttle.Reset();
			Verdict v = Verdict.Certain("stress-test", "synthetic flood");
			Stopwatch stopwatch = Stopwatch.StartNew();
			int num = 0;
			for (int i = 0; i < count; i++)
			{
				if (Throttle.ShouldReport(4242uL, "stress-test", v))
				{
					num++;
				}
			}
			stopwatch.Stop();
			long num2 = Math.Max(1L, stopwatch.ElapsedMilliseconds);
			long num3 = (long)((double)count / ((double)num2 / 1000.0));
			List<string> list = new List<string>
			{
				$"Flooded {count:N0} findings in {num2} ms  ({num3:N0}/sec)",
				$"  reported {num}, suppressed {count - num}",
				$"  before the throttle this was {count:N0} disk writes and {count:N0} chat broadcasts"
			};
			if (num > count / 50)
			{
				list.Add("  WARNING: too many got through the throttle - lower SecondsBetweenRepeatReports");
			}
			else
			{
				list.Add("  reporting held up. The crash from 24 Aug would not repeat.");
			}
			Throttle.Reset();
			foreach (string item in list)
			{
				Plugin.Log.LogInfo((object)("[Stress] " + item));
			}
			return list;
		}

		private static void ResponseMatrix()
		{
			List<string> list = Rules.Catalogue.Where((string r) => Response.FamilyOf(r) == Response.Family.Other).ToList();
			Check("every rule has a family", list.Count == 0, list.Count + " unclassified, so they fall through to no response: " + string.Join(", ", list.Take(6).ToArray()));
			List<string> list2 = Rules.Catalogue.Where((string r) => Response.FamilyOf(r) == Response.Family.Movement && Response.Trolls(r)).ToList();
			Check("measured rules do not answer back", list2.Count == 0, "these would haze somebody on a measurement: " + string.Join(", ", list2.ToArray()));
			List<string> list3 = Rules.Catalogue.Where((string r) => Response.FamilyOf(r) == Response.Family.Attack && Response.Trolls(r)).ToList();
			Check("attacks are not hazed", list3.Count == 0, "these would haze somebody already removed: " + string.Join(", ", list3.ToArray()));
			Check("economy is refused", Rules.Catalogue.Where((string r) => Response.FamilyOf(r) == Response.Family.Economy).All(Response.Blocks), "an economy rule is set to record only - money does not undo itself");
		}

		private static void SanityValues()
		{
			//IL_0014: 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_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: 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)
			Check("infinity is not a place", !Body.Sane(new Vector3(float.PositiveInfinity, 0f, 0f)), "an infinite coordinate would be accepted");
			Check("NaN is not a place", !Body.Sane(new Vector3(float.NaN, 0f, 0f)), "a NaN coordinate would be accepted");
			Check("1e38 is not a place", !Body.Sane(new Vector3(1E+38f, 0f, 0f)), "the coordinate that crashed the lobby would be accepted");
			Check("the map is a place", Body.Sane(new Vector3(-191.7f, -0.6f, 594.8f)), "a real position from the log would be refused");
			Check("the origin is a place", Body.Sane(Vector3.zero), "the world origin would be refused, which would break spawning");
		}

		private static void AttackTiers()
		{
			string[] first = new string[4] { "teleport-crash", "bad-numbers", "lobby-crash", "clone-spawn" };
			string[] second = new string[2] { "crash-packet", "packet-flood" };
			Check("crash rules are catalogued", first.Concat(second).All((string r) => Rules.Catalogue.Contains(r)), "a crash rule is missing from the catalogue, so it cannot be switched off");
			Check("crash rules are all attacks", first.Concat(second).All((string r) => Response.FamilyOf(r) == Response.Family.Attack), "a crash rule is not classified as an attack");
			Check("crash rules are refused", first.Concat(second).All(Response.Blocks), "a crash rule is set to record only - the lobby would go down");
		}
	}
	internal static class Sender
	{
		public static NetworkConnection Current { get; private set; }

		public static void Capture(NetworkConnection conn)
		{
			Current = conn;
		}

		public static void Clear()
		{
			Current = null;
		}

		public static bool IsTrusted(NetworkConnection conn)
		{
			if (conn == (NetworkConnection)null)
			{
				return true;
			}
			if (IsHost(conn))
			{
				return true;
			}
			return Crew.Contains(conn);
		}

		public static bool IsHost(NetworkConnection conn)
		{
			if (conn == (NetworkConnection)null)
			{
				return true;
			}
			try
			{
				Player localPlayer = Player.LocalPlayer;
				if ((Object)(object)localPlayer != (Object)null && ((NetworkBehaviour)localPlayer).Owner == conn)
				{
					return true;
				}
			}
			catch
			{
			}
			try
			{
				ClientManager clientManager = InstanceFinder.ClientManager;
				if ((Object)(object)clientManager != (Object)null && clientManager.Connection == conn)
				{
					return true;
				}
			}
			catch
			{
			}
			return false;
		}

		public static string NameOf(NetworkConnection conn)
		{
			if (conn == (NetworkConnection)null)
			{
				return "(local)";
			}
			Player val = PlayerFor(conn);
			if ((Object)(object)val != (Object)null && !string.IsNullOrEmpty(val.SteamName))
			{
				return val.SteamName;
			}
			return "conn#" + conn.ClientId;
		}

		public static Player PlayerFor(NetworkConnection conn)
		{
			if (conn == (NetworkConnection)null)
			{
				return null;
			}
			try
			{
				List<Player> players = PlayerManager.Players;
				if (players == null)
				{
					return null;
				}
				foreach (Player item in players)
				{
					if ((Object)(object)item != (Object)null && ((NetworkBehaviour)item).Owner == conn)
					{
						return item;
					}
				}
			}
			catch
			{
			}
			return null;
		}

		public static ulong KeyOf(NetworkConnection conn)
		{
			Player val = PlayerFor(conn);
			if ((Object)(object)val != (Object)null)
			{
				try
				{
					if (val.SteamID != 0L)
					{
						return val.SteamID;
					}
				}
				catch
				{
				}
			}
			if (!(conn == (NetworkConnection)null))
			{
				return (ulong)(1000000 + conn.ClientId);
			}
			return 0uL;
		}
	}
	internal static class Crew
	{
		private static readonly HashSet<ulong> _trusted = new HashSet<ulong>();

		public static int Count => _trusted.Count;

		public static IEnumerable<ulong> All => _trusted;

		public static bool Contains(NetworkConnection conn)
		{
			if (conn == (NetworkConnection)null)
			{
				return true;
			}
			Player val = Sender.PlayerFor(conn);
			if ((Object)(object)val == (Object)null)
			{
				return false;
			}
			try
			{
				return _trusted.Contains(val.SteamID);
			}
			catch
			{
				return false;
			}
		}

		public static bool Add(ulong steamId)
		{
			return _trusted.Add(steamId);
		}

		public static bool Remove(ulong steamId)
		{
			return _trusted.Remove(steamId);
		}

		public static string Grant(Player p)
		{
			if ((Object)(object)p == (Object)null)
			{
				return "Nobody by that name.";
			}
			ulong steamID;
			try
			{
				steamID = p.SteamID;
			}
			catch
			{
				return "Could not read who that is.";
			}
			if (!_trusted.Add(steamID))
			{
				return p.SteamName + " already has a fishing license.";
			}
			Plugin.Log.LogWarning((object)($"[License] {p.SteamName} ({steamID}) issued a fishing license - " + "their traffic is no longer inspected by any rule."));
			try
			{
				Chat.Ok(p.SteamName + " has been issued a fishing license. The warden will not look at them, whatever they get up to.");
			}
			catch
			{
			}
			return p.SteamName + " has a fishing license - nothing they do is inspected.";
		}

		public static string Revoke(Player p)
		{
			if ((Object)(object)p == (Object)null)
			{
				return "Nobody by that name.";
			}
			ulong steamID;
			try
			{
				steamID = p.SteamID;
			}
			catch
			{
				return "Could not read who that is.";
			}
			if (!_trusted.Remove(steamID))
			{
				return p.SteamName + " did not have a license.";
			}
			Plugin.Log.LogWarning((object)$"[License] {p.SteamName} ({steamID})'s fishing license is revoked.");
			try
			{
				Chat.Info(p.SteamName + "'s fishing license has been revoked.");
			}
			catch
			{
			}
			return p.SteamName + "'s license is revoked - the warden is watching them again.";
		}

		public static string Toggle(Player p)
		{
			if ((Object)(object)p == (Object)null)
			{
				return "Nobody by that name.";
			}
			ulong steamID;
			try
			{
				steamID = p.SteamID;
			}
			catch
			{
				return "Could not read who that is.";
			}
			if (!_trusted.Contains(steamID))
			{
				return Grant(p);
			}
			return Revoke(p);
		}

		public static bool Has(ulong steamId)
		{
			return _trusted.Contains(steamId);
		}
	}
	internal static class Smite
	{
		private static float _lastSmite = -999f;

		public static Player Aimed()
		{
			//IL_00d5: 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_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: 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_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_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)
			//IL_00ff: 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_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: 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_0070: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				Player localPlayer = Player.LocalPlayer;
				if ((Object)(object)localPlayer == (Object)null)
				{
					return null;
				}
				Camera curCam = localPlayer.CurCam;
				Vector3 val = (((Object)(object)curCam != (Object)null) ? ((Component)curCam).transform.position : (Body.Of(localPlayer) + Vector3.up * 1.5f));
				Vector3 val2 = (((Object)(object)curCam != (Object)null) ? ((Component)curCam).transform.forward : ((Component)localPlayer).transform.forward);
				Player result = null;
				float num = Plugin.SmiteFov.Value;
				foreach (Player player in PlayerManager.Players)
				{
					if ((Object)(object)player == (Object)null || (Object)(object)player == (Object)(object)localPlayer)
					{
						continue;
					}
					try
					{
						if ((Object)(object)player.Dying != (Object)null && player.Dying.IsDead)
						{
							continue;
						}
					}
					catch
					{
					}
					Vector3 val3 = Body.Of(player) + Vector3.up - val;
					if (!(((Vector3)(ref val3)).magnitude > Plugin.SmiteRange.Value))
					{
						float num2 = Vector3.Angle(val2, val3);
						if (!(num2 > num))
						{
							num = num2;
							result = player;
						}
					}
				}
				return result;
			}
			catch
			{
				return null;
			}
		}

		public static string Strike()
		{
			if (!Plugin.IsHosting)
			{
				return "Only the host can smite.";
			}
			float realtimeSinceStartup = Time.realtimeSinceStartup;
			if (realtimeSinceStartup - _lastSmite < Plugin.SmiteCooldown.Value)
			{
				return null;
			}
			_lastSmite = realtimeSinceStartup;
			Player val = Aimed();
			if ((Object)(object)val == (Object)null)
			{
				return "Nothing in your crosshair.";
			}
			return Hit(val);
		}

		public static string Strike(Player target)
		{
			if (!Plugin.IsHosting)
			{
				return "Only the host can smite.";
			}
			if ((Object)(object)target == (Object)null)
			{
				return "Nobody is selected.";
			}
			return Hit(target);
		}

		private static string Hit(Player target)
		{
			//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_0017: 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_002b: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				Vector3 val = Body.Of(target);
				Server.Instance.HitPlayer(target, Plugin.SmiteDamage.Value, Vector3.up * Plugin.SmiteLaunch.Value, val, (byte)2, (Player)null);
				Plugin.Log.LogWarning((object)("[Smite] " + target.SteamName + " struck down by the host."));
				return target.SteamName + " has been smitten.";
			}
			catch (Exception ex)
			{
				return "Could not smite: " + ex.Message;
			}
		}

		public static string AimedName()
		{
			Player val = Aimed();
			if ((Object)(object)val == (Object)null)
			{
				return null;
			}
			try
			{
				return val.SteamName;
			}
			catch
			{
				return null;
			}
		}
	}
	internal static class TackleCheck
	{
		public static bool Passed { get; private set; }

		public static List<string> Failures { get; } = new List<string>();

		public static List<string> Degraded { get; } = new List<string>();

		public static int Resolved { get; private set; }

		public static bool Run()
		{
			Failures.Clear();
			Degraded.Clear();
			Resolved = 0;
			Assembly assembly = typeof(Player).Assembly;
			Type type = assembly.GetType("Server");
			Type type2 = assembly.GetType("Player");
			if (type == null)
			{
				Failures.Add("type 'Server' not found");
				return Finish();
			}
			if (type2 == null)
			{
				Failures.Add("type 'Player' not found");
				return Finish();
			}
			foreach (Rpc item in Targets.All)
			{
				try
				{
					item.Reader = Targets.Resolve(type, "RpcReader", item.Name);
					item.Logic = Targets.Resolve(type, "RpcLogic", item.Name);
				}
				catch (AmbiguousMatchException ex)
				{
					Record(item.Critical, item.Name + ": " + ex.Message);
					continue;
				}
				if (item.Reader == null || item.Logic == null)
				{
					string text = ((item.Reader == null && item.Logic == null) ? "reader and logic" : ((item.Reader == null) ? "reader" : "logic"));
					Record(item.Critical, item.Name + ": " + text + " not found");
				}
				else if (AccessTools.Method(typeof(Guard), item.Prefix, (Type[])null, (Type[])null) == null)
				{
					Record(item.Critical, item.Name + ": Guard." + item.Prefix + " missing");
				}
				else
				{
					Resolved++;
				}
			}
			if (Targets.Resolve(type, "RpcLogic", "UpdatePlayerPosRot") == null)
			{
				Degraded.Add("UpdatePlayerPosRot not found - no speed or flight detection");
			}
			if (Targets.Resolve(type2, "RpcLogic", "RPCTeleport") == null)
			{
				Degraded.Add("Player.RPCTeleport not found - Anchor unavailable");
			}
			CheckMember(type2, "SteamName");
			CheckMember(type2, "SteamID");
			CheckMember(type2, "Movement");
			return Finish();
		}

		private static void Record(bool critical, string msg)
		{
			if (critical)
			{
				Failures.Add(msg);
			}
			else
			{
				Degraded.Add(msg);
			}
		}

		private static void CheckMember(Type t, string member)
		{
			if (AccessTools.Property(t, member) == null && AccessTools.Field(t, member) == null)
			{
				Degraded.Add(t.Name + "." + member + " not found");
			}
		}

		private static bool Finish()
		{
			Passed = Failures.Count == 0;
			if (Passed)
			{
				Plugin.Log.LogInfo((object)$"[TackleCheck] {Resolved}/{Targets.All.Count} RPC guards resolved.");
				foreach (string item in Degraded)
				{
					Plugin.Log.LogWarning((object)("[TackleCheck] reduced cover: " + item));
				}
				if (Degraded.Count > 0)
				{
					Plugin.Log.LogWarning((object)$"[TackleCheck] armed, but {Degraded.Count} capability(s) unavailable - see above.");
				}
			}
			else
			{
				Plugin.Log.LogError((object)"================ FISHWARDEN DISARMED ================");
				Plugin.Log.LogError((object)"The game has changed since this build. Fishwarden will NOT");
				Plugin.Log.LogError((object)"inspect anything, because a guard that half-works is worse");
				Plugin.Log.LogError((object)"than one that is honestly off. Missing:");
				foreach (string failure in Failures)
				{
					Plugin.Log.LogError((object)("   - " + failure));
				}
				Plugin.Log.LogError((object)"Update the mod against the current Assembly-CSharp.dll.");
				Plugin.Log.LogError((object)"=====================================================");
			}
			return Passed;
		}

		public static void ForceDisarm(string why)
		{
			Passed = false;
			Failures.Add(why);
		}

		public static string Summary()
		{
			if (!Passed)
			{
				return $"DISARMED - {Failures.Count} critical target(s) missing";
			}
			if (Degraded.Count != 0)
			{
				return $"{Resolved} guards armed, {Degraded.Count} reduced";
			}
			return $"{Resolved} guards armed";
		}
	}
	internal sealed class Rpc
	{
		public string Name;

		public string Prefix;

		public bool Critical;

		public MethodInfo Reader;

		public MethodInfo Logic;
	}
	internal static class Targets
	{
		public static readonly List<Rpc> All = new List<Rpc>
		{
			new Rpc
			{
				Name = "TeleportPlayer",
				Prefix = "Teleport_Pre",
				Critical = true
			},
			new Rpc
			{
				Name = "HitPlayer",
				Prefix = "HitPlayer_Pre",
				Critical = true
			},
			new Rpc
			{
				Name = "BuyItem",
				Prefix = "BuyItem_Pre",
				Critical = true
			},
			new Rpc
			{
				Name = "DropAllItems",
				Prefix = "DropAllItems_Pre",
				Critical = true
			},
			new Rpc
			{
				Name = "SendFinishGame",
				Prefix = "FinishGame_Pre",
				Critical = true
			},
			new Rpc
			{
				Name = "SetItemMultiplier",
				Prefix = "SetItemMultiplier_Pre"
			},
			new Rpc
			{
				Name = "ResurrectPlayer",
				Prefix = "ResurrectPlayer_Pre"
			},
			new Rpc
			{
				Name = "RespawnPlayer",
				Prefix = "RespawnPlayer_Pre"
			},
			new Rpc
			{
				Name = "BuyBait",
				Prefix = "BuyBait_Pre"
			},
			new Rpc
			{
				Name = "BuyBoatMotor",
				Prefix = "BuyBoatMotor_Pre"
			},
			new Rpc
			{
				Name = "BuyBoatRadar",
				Prefix = "BuyBoatRadar_Pre"
			},
			new Rpc
			{
				Name = "BuyAttachment",
				Prefix = "BuyAttachment_Pre"
			},
			new Rpc
			{
				Name = "BuyBulletUpgrade",
				Prefix = "BuyBulletUpgrade_Pre"
			},
			new Rpc
			{
				Name = "BuySharpnessUpgrade",
				Prefix = "BuySharpnessUpgrade_Pre"
			},
			new Rpc
			{
				Name = "SetItemHolder",
				Prefix = "SetItemHolder_Pre"
			},
			new Rpc
			{
				Name = "RemoveItemFromInventory",
				Prefix = "RemoveItemFromInventory_Pre"
			},
			new Rpc
			{
				Name = "PutItemInInventory",
				Prefix = "PutItemInInventory_Pre"
			},
			new Rpc
			{
				Name = "TakeItemFromNpc",
				Prefix = "TakeItemFromNpc_Pre"
			},
			new Rpc
			{
				Name = "UnlockPocket",
				Prefix = "UnlockPocket_Pre"
			},
			new Rpc
			{
				Name = "SendChatMessage",
				Prefix = "SendChatMessage_Pre"
			},
			new Rpc
			{
				Name = "ActivateExplosive",
				Prefix = "ActivateExplosive_Pre"
			},
			new Rpc
			{
				Name = "SetDriver",
				Prefix = "SetDriver_Pre"
			},
			new Rpc
			{
				Name = "HitCreature",
				Prefix = "HitCreature_Pre"
			},
			new Rpc
			{
				Name = "MeleeAttack",
				Prefix = "MeleeAttack_Pre"
			},
			new Rpc
			{
				Name = "Punch",
				Prefix = "Punch_Pre"
			},
			new Rpc
			{
				Name = "SetItemSkin",
				Prefix = "SetItemSkin_Pre"
			},
			new Rpc
			{
				Name = "SetBoatSkin",
				Prefix = "SetBoatSkin_Pre"
			},
			new Rpc
			{
				Name = "PlaceBet",
				Prefix = "PlaceBet_Pre"
			},
			new Rpc
			{
				Name = "FinishEatingCreature",
				Prefix = "FinishEatingCreature_Pre"
			},
			new Rpc
			{
				Name = "ToggleEatCreature",
				Prefix = "ToggleEatCreature_Pre"
			},
			new Rpc
			{
				Name = "AddProjectile",
				Prefix = "AddProjectile_Pre"
			},
			new Rpc
			{
				Name = "AddProjectiles",
				Prefix = "AddProjectiles_Pre"
			},
			new Rpc
			{
				Name = "ProjectileHitDynamic",
				Prefix = "ProjectileHitDynamic_Pre"
			},
			new Rpc
			{
				Name = "ReleaseItemFromBait",
				Prefix = "ReleaseItemFromBait_Pre"
			},
			new Rpc
			{
				Name = "HandOverItemSimulation",
				Prefix = "HandOverItemSimulation_Pre"
			},
			new Rpc
			{
				Name = "ChangeBait",
				Prefix = "ChangeBait_Pre"
			},
			new Rpc
			{
				Name = "ReloadWeapon",
				Prefix = "ReloadWeapon_Pre"
			}
		};

		private const BindingFlags Any = BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic;

		public static MethodInfo Resolve(Type type, string kind, string name)
		{
			string prefix = kind + "___" + name + "___";
			List<MethodInfo> list = (from m in type.GetMethods(BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic)
				where m.Name.StartsWith(prefix, StringComparison.Ordinal)
				select m).ToList();
			if (list.Count == 0)
			{
				return null;
			}
			if (list.Count > 1)
			{
				throw new AmbiguousMatchException($"{type.Name}.{prefix}* matched {list.Count} methods: " + string.Join(", ", list.Select((MethodInfo h) => h.Name)));
			}
			return list[0];
		}
	}
	internal static class Theme
	{
		private static bool _pulled;

		private static Color _accent = new Color(0.42f, 0.76f, 0.94f);

		private static Color _good = new Color(0.45f, 0.83f, 0.6f);

		private static Color _warn = new Color(0.95f, 0.74f, 0.36f);

		private static Color _bad = new Color(0.95f, 0.44f, 0.38f);

		private static Color _urgent = new Color(1f, 0.83f, 0.28f);

		public static readonly Color Panel = new Color(0.055f, 0.09f, 0.13f, 0.97f);

		public static readonly Color Card = new Color(1f, 1f, 1f, 0.045f);

		public static readonly Color Divide = new Color(1f, 1f, 1f, 0.13f);

		public static readonly Color Row = new Color(0.02f, 0.04f, 0.07f, 0.58f);

		public static readonly Color RowOn = new Color(0.02f, 0.04f, 0.07f, 0.8f);

		public static readonly Color Glass = new Color(0.2f, 0.19f, 0.17f, 0.74f);

		public static readonly Color GlassBase = Color.white;

		public static readonly Color EdgeWarden = new Color(0.48f, 0.78f, 0.96f, 0.85f);

		public static readonly Color EdgeTweaks = new Color(0.93f, 0.36f, 0.33f, 0.85f);

		public static readonly Color EdgeLive = new Color(1f, 1f, 1f, 0.95f);

		public static readonly Color EdgeIdle = new Color(1f, 1f, 1f, 0.22f);

		public static readonly Color EdgeGrave = new Color(0.93f, 0.36f, 0.33f, 0.9f);

		public static readonly Color RowArmed = new Color(0.28f, 0.06f, 0.05f, 0.88f);

		public const int Gap = 6;

		public const int Pad = 12;

		public const int RowH = 30;

		private static readonly Dictionary<int, Texture2D> _solids = new Dictionary<int, Texture2D>();

		public static Color Ink => NativeLook.MenuText;

		public static Color Muted => new Color(NativeLook.MenuText.r, NativeLook.MenuText.g, NativeLook.MenuText.b, 0.62f);

		public static Color Faint => new Color(NativeLook.MenuText.r, NativeLook.MenuText.g, NativeLook.MenuText.b, 0.3f);

		public static Color Accent
		{
			get
			{
				//IL_0005: Unknown result type (might be due to invalid IL or missing references)
				Pull();
				return _accent;
			}
		}

		public static Color Good
		{
			get
			{
				//IL_0005: Unknown result type (might be due to invalid IL or missing references)
				Pull();
				return _good;
			}
		}

		public static Color Warn
		{
			get
			{
				//IL_0005: Unknown result type (might be due to invalid IL or missing references)
				Pull();
				return _warn;
			}
		}

		public static Color Bad
		{
			get
			{
				//IL_0005: Unknown result type (might be due to invalid IL or missing references)
				Pull();
				return _bad;
			}
		}

		public static Color Urgent
		{
			get
			{
				//IL_0005: Unknown result type (might be due to invalid IL or missing references)
				Pull();
				return _urgent;
			}
		}

		private static void Pull()
		{
			//IL_0009: 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_000f: 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)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: 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)
			//IL_003e: 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_005b: 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_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_0088: 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_006e: Unknown result type (might be due to invalid IL or missing references)
			//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_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_0095: 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_00a0: Unknown result type (might be due to invalid IL or missing references)
			if (_pulled)
			{
				return;
			}
			try
			{
				Color redColor = GameInfo.RedColor;
				Color greenColor = GameInfo.GreenColor;
				Color orangeColor = GameInfo.OrangeColor;
				Color rareColor = GameInfo.RareColor;
				if (redColor.a > 0.1f)
				{
					_bad = Brighten(redColor);
				}
				if (greenColor.a > 0.1f)
				{
					_good = Brighten(greenColor);
				}
				if (orangeColor.a > 0.1f)
				{
					_warn = Brighten(orangeColor);
					_urgent = Brighten(orangeColor, 1.15f);
				}
				if (rareColor.a > 0.1f)
				{
					_accent = Brighten(rareColor);
				}
				_pulled = true;
				Plugin.Log.LogInfo((object)"[Theme] using the game's own colours.");
			}
			catch
			{
			}
		}

		private static Color Brighten(Color c, float extra = 1f)
		{
			//IL_0000: 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_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			float num = default(float);
			float num3 = default(float);
			float num2 = default(float);
			Color.RGBToHSV(c, ref num, ref num2, ref num3);
			num3 = Mathf.Clamp01(Mathf.Max(num3, 0.78f) * extra);
			num2 = Mathf.Clamp01(num2 * 0.88f);
			Color result = Color.HSVToRGB(num, num2, num3);
			result.a = 1f;
			return result;
		}

		public unsafe static Texture2D Solid(Color c)
		{
			//IL_002a: 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_0038: Expected O, but got Unknown
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			int hashCode = ((object)(*(Color*)(&c))/*cast due to .constrained prefix*/).GetHashCode();
			if (_solids.TryGetValue(hashCode, out var value) && (Object)(object)value != (Object)null)
			{
				return value;
			}
			value = new Texture2D(1, 1)
			{
				hideFlags = (HideFlags)61
			};
			value.SetPixel(0, 0, c);
			value.Apply();
			_solids[hashCode] = value;
			return value;
		}

		public static void Pill(string text, Color tint)
		{
			//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_0017: 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_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Expected O, but got Unknown
			//IL_002d: 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_0039: 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_0045: 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_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Expected O, but got Unknown
			GUIStyle val = new GUIStyle(GUI.skin.label)
			{
				fontSize = 12,
				alignment = (TextAnchor)4,
				padding = new RectOffset(8, 8, 3, 3)
			};
			val.normal.textColor = tint;
			val.normal.background = Solid(new Color(tint.r, tint.g, tint.b, 0.16f));
			GUIStyle val2 = val;
			GUILayout.Label(text, val2, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(20f) });
		}

		public static void Header(string text)
		{
			//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_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_0034: 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_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Expected O, but got Unknown
			GUILayout.Space(6f);
			Color color = GUI.color;
			GUI.color = Ink;
			GUIStyle val = new GUIStyle(GUI.skin.label)
			{
				fontSize = NativeLook.MenuSize,
				fontStyle = (FontStyle)1
			};
			val.normal.textColor = Ink;
			GUILayout.Label(text, val, Array.Empty<GUILayoutOption>());
			GUI.color = color;
		}

		public static void Stat(string value, string caption, Color tint)
		{
			//IL_0018: 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_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_003b: 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_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Expected O, but got Unknown
			//IL_0058: 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)
			//IL_007a: 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_0094: Expected O, but got Unknown
			GUILayout.BeginVertical((GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(110f) });
			Color color = GUI.color;
			GUI.color = tint;
			GUIStyle val = new GUIStyle(GUI.skin.label)
			{
				fontSize = 22,
				fontStyle = (FontStyle)1
			};
			val.normal.textColor = tint;
			GUILayout.Label(value, val, Array.Empty<GUILayoutOption>());
			GUI.color = Faint;
			GUIStyle val2 = new GUIStyle(GUI.skin.label)
			{
				fontSize = 11
			};
			val2.normal.textColor = Muted;
			GUILayout.Label(caption, val2, Array.Empty<GUILayoutOption>());
			GUI.color = color;
			GUILayout.EndVertical();
		}

		public static void Rule()
		{
			//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_002d: 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_0042: Unknown result type (might be due to invalid IL or missing references)
			GUILayout.Space(6f);
			Rect rect = GUILayoutUtility.GetRect(1f, 1f, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.ExpandWidth(true) });
			Color color = GUI.color;
			GUI.color = Divide;
			GUI.DrawTexture(rect, (Texture)(object)Texture2D.whiteTexture);
			GUI.color = color;
			GUILayout.Space(6f);
		}

		public static void Line(string text, Color c, int size = 0)
		{
			//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_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: 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_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Expected O, but got Unknown
			Color color = GUI.color;
			GUI.color = c;
			GUIStyle val = new GUIStyle(GUI.skin.label)
			{
				fontSize = ((size > 0) ? size : NativeLook.MenuSize),
				fontStyle = (FontStyle)(NativeLook.MenuBold ? 1 : 0)
			};
			val.normal.textColor = c;
			GUILayout.Label(text, val, Array.Empty<GUILayoutOption>());
			GUI.color = color;
		}

		public static Color ForStrikes(int strikes, int threshold)
		{
			//IL_0014: 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_0008: Unknown result type (might be due to invalid IL or missing references)
			if (strikes < threshold)
			{
				if (strikes <= 0)
				{
					return Good;
				}
				return Warn;
			}
			return Bad;
		}
	}
	internal static class Throttle
	{
		private sealed class Burst
		{
			public int Suppressed;

			public float First;

			public float Last;

			public float LastReported;

			public string Who;

			public string Rule;

			public string Detail;
		}

		private static readonly Dictionary<string, Burst> _bursts = new Dictionary<string, Burst>();

		public static int TotalSuppressed => _bursts.Values.Sum((Burst b) => b.Suppressed);

		public static bool ShouldReport(ulong key, string who, Verdict v)
		{
			string key2 = key + ":" + (v.Rule ?? "?");
			float realtimeSinceStartup = Time.realtimeSinceStartup;
			if (!_bursts.TryGetValue(key2, out var value))
			{
				value = new Burst
				{
					First = realtimeSinceStartup,
					LastReported = realtimeSinceStartup,
					Who = who,
					Rule = v.Rule,
					Detail = v.Detail
				};
				_bursts[key2] = value;
				return true;
			}
			value.Last = realtimeSinceStartup;
			value.Who = who;
			value.Detail = v.Detail;
			if (realtimeSinceStartup - value.LastReported >= Plugin.ReportInterval.Value)
			{
				value.LastReported = realtimeSinceStartup;
				if (value.Suppressed > 0)
				{
					Plugin.Log.LogWarning((object)($"[Fishwarden] {who}: {value.Suppressed} more of '{v.Rule}' " + $"suppressed in the last {Plugin.ReportInterval.Value:0}s (all blocked)"));
					value.Suppressed = 0;
				}
				return true;
			}
			value.Suppressed++;
			return false;
		}

		public static int SuppressedFor(ulong key, string rule)
		{
			if (!_bursts.TryGetValue(key + ":" + rule, out var value))
			{
				return 0;
			}
			return value.Suppressed;
		}

		public static void Reset()
		{
			_bursts.Clear();
		}
	}
	internal static class Summary
	{
		private sealed class Tally
		{
			public int Count;

			public int Blocked;

			public DateTime First;

			public DateTime Last;

			public Confidence Worst;

			public string Example;
		}

		private static readonly Dictionary<ulong, Dictionary<string, Tally>> _by = new Dictionary<ulong, Dictionary<string, Tally>>();

		private static readonly Dictionary<ulong, string> _names = new Dictionary<ulong, string>();

		private static readonly Dictionary<string, string> Explanations = new Dictionary<string, string>
		{
			["auto-fire"] = null,
			["bait-not-owned"] = null,
			["bait-release-other"] = null,
			["bait-set-other"] = null,
			["boat-hijack"] = null,
			["bought-a-creature"] = null,
			["bought-unpriced"] = null,
			["catch-limit"] = null,
			["chat-impersonation"] = null,
			["chum"] = null,
			["creature-damage-above-weapon"] = null,
			["creature-damage-impossible"] = null,
			["creature-damage-spoof"] = null,
			["creature-hit-from-nowhere"] = null,
			["damage-above-weapon"] = null,
			["damage-impossible"] = null,
			["damage-spoof"] = null,
			["eat-as-other"] = null,
			["eat-toggle-other"] = null,
			["flight"] = null,
			["flying"] = null,
			["force-drop"] = null,
			["force-finish"] = null,
			["free-purchase"] = null,
			["hit-from-nowhere"] = null,
			["inventory-push"] = null,
			["inventory-take"] = null,
			["item-move"] = null,
			["lobby-crash"] = null,
			["no-reload"] = null,
			["noclip"] = null,
			["not-for-sale"] = null,
			["npc-take"] = null,
			["perfect-accuracy"] = null,
			["persistent-flight"] = null,
			["physics-grab"] = null,
			["pocket-unlock"] = null,
			["projectile-flood"] = null,
			["projectile-spoof"] = null,
			["purchase-other"] = null,
			["reload-other"] = null,
			["remote-detonate"] = null,
			["respawn-other"] = null,
			["self-revive"] = null,
			["shot-through-wall"] = null,
			["speed"] = null,
			["teleport-other"] = null,
			["teleport-self"] = null,
			["walking-on-water"] = null,
			["worth-inflation"] = null,
			["worth-nudge"] = null
		};

		public static int PlayerCount => _by.Count;

		public static void Note(ulong key, string who, Verdict v, bool blocked)
		{
			if (v.Rule != null)
			{
				_names[key] = who;
				if (!_by.TryGetValue(key, out var value))
				{
					value = new Dictionary<string, Tally>();
					_by[key] = value;
				}
				if (!value.TryGetValue(v.Rule, out var value2))
				{
					value2 = new Tally
					{
						First = DateTime.Now,
						Worst = v.Confidence,
						Example = v.Detail
					};
					value[v.Rule] = value2;
				}
				value2.Count++;
				if (blocked)
				{
					value2.Blocked++;
				}
				value2.Last = DateTime.Now;
				if (v.Confidence > value2.Worst)
				{
					value2.Worst = v.Confidence;
					value2.Example = v.Detail;
				}
			}
		}

		public static string Explain(string rule)
		{
			if (rule != null && Explanations.TryGetValue(rule, out var value))
			{
				return value;
			}
			switch (rule)
			{
			case "free-purchase":
				return "spawning items for free";
			case "not-for-sale":
				return "buying things no shop sells";
			case "bought-a-creature":
				return "spawning fish and bosses";
			case "bought-unpriced":
				return "buying unpriced items";
			case "purchase-other":
				return "buying as someone else";
			case "damage-spoof":
				return "damage blamed on someone else";
			case "damage-impossible":
				return "impossible damage to players";
			case "damage-above-weapon":
				return "hitting harder than their weapon can";
			case "creature-damage-above-weapon":
				return "hitting fish harder than their weapon can";
			case "creature-damage-impossible":
				return "impossible damage to creatures";
			case "creature-damage-spoof":
				return "creature damage as someone else";
			case "teleport-other":
				return "teleporting other players";
			case "teleport-self":
				return "teleporting themselves around";
			case "respawn-other":
				return "respawning others somewhere else";
			case "force-drop":
				return "forcing people to drop everything";
			case "force-finish":
				return "trying to end the run";
			case "lobby-crash":
				return "CRASHING THE LOBBY";
			case "chat-impersonation":
				return "posting chat as someone else";
			case "worth-inflation":
				return "inflating sell values";
			case "self-revive":
			case "self-revive-spam":
				return "reviving themselves";
			case "physics-grab":
				return "taking control of others' items";
			case "boat-hijack":
				return "hijacking boats";
			case "remote-detonate":
				return "detonating explosives remotely";
			case "chum":
				return "took bait only reachable by flying";
			case "speed":
				return "moving too fast";
			case "bait-not-owned":
				return "using bait they never bought";
			case "bait-set-other":
				return "changing someone else's bait";
			case "noclip":
				return "moving through walls";
			case "persistent-flight":
				return "flying after repeated warnings";
			case "walking-on-water":
				return "walking on water";
			case "shot-through-wall":
				return "shooting through walls";
			case "perfect-accuracy":
				return "never missing";
			case "hit-from-nowhere":
				return "hitting people from impossible distance";
			case "creature-hit-from-nowhere":
				return "hitting fish from impossible distance";
			case "no-reload":
				return "shooting without reloading";
			case "auto-fire":
				return "shooting faster than the gun allows";
			case "flight":
				return "flying";
			case "flying":
				return "flying (put back down)";
			case "catch-limit":
				return "acting faster than humanly possible";
			case "projectile-flood":
				return "flooding the server with projectiles";
			case "inventory-take":
			case "inventory-push":
			case "item-move":
				return "moving other people's items";
			default:
				return rule;
			}
		}

		public static IEnumerable<string> KnownRules()
		{
			return Explanations.Keys;
		}

		public static List<string> LinesFor(ulong key)
		{
			List<string> list = new List<string>();
			if (!_by.TryGetValue(key, out var value) || value.Count == 0)
			{
				return list;
			}
			foreach (KeyValuePair<string, Tally> item in value.OrderByDescending((KeyValuePair<string, Tally> x) => x.Value.Count))
			{
				Tally value2 = item.Value;
				string text = ((value2.Blocked == value2.Count) ? "all stopped" : ((value2.Blocked == 0) ? "NONE STOPPED" : $"{value2.Blocked}/{value2.Count} stopped"));
				list.Add(string.Format("{0} {1}  x{2}  ({3})", (value2.Worst == Confidence.Certain) ? "!" : " ", Explain(item.Key), value2.Count, text));
			}
			return list;
		}

		public static bool HasAnything(ulong key)
		{
			return _by.ContainsKey(key);
		}

		public static int ProvenCount(ulong key)
		{
			if (!_by.TryGetValue(key, out var value))
			{
				return 0;
			}
			return value.Values.Count((Tally t) => t.Worst == Confidence.Certain);
		}

		public static int AttemptCount(ulong key)
		{
			if (!_by.TryGetValue(key, out var value))
			{
				return 0;
			}
			return value.Values.Sum((Tally t) => t.Count);
		}

		public static DateTime? FirstSeen(ulong key)
		{
			if (!_by.TryGetValue(key, out var value) || value.Count <= 0)
			{
				return null;
			}
			return value.Values.Min((Tally t) => t.First);
		}

		public static List<string> Lines(bool includeClean = true)
		{
			List<string> list = new List<string>();
			if (_by.Count == 0)
			{
				if (includeClean)
				{
					list.Add("Nobody has tried anything. Clean session.");
				}
				return list;
			}
			foreach (KeyValuePair<ulong, Dictionary<string, Tally>> item in _by.OrderByDescending((KeyValuePair<ulong, Dictionary<string, Tally>> k) => k.Value.Values.Sum((Tally t) => t.Count)))
			{
				string value;
				string arg = (_names.TryGetValue(item.Key, out value) ? value : ("#" + item.Key));
				int num = item.Value.Values.Sum((Tally t) => t.Count);
				int num2 = item.Value.Values.Count((Tally t) => t.Worst == Confidence.Certain);
				list.Add($"{arg} - {num} attempt(s), {num2} proven");
				foreach (KeyValuePair<string, Tally> item2 in item.Value.OrderByDescending((KeyValuePair<string, Tally> x) => x.Value.Count))
				{
					Tally value2 = item2.Value;
					string text = ((value2.Worst == Confidence.Certain) ? "!" : " ");
					string text2 = ((value2.Blocked == value2.Count) ? "all stopped" : ((value2.Blocked == 0) ? "NONE stopped" : $"{value2.Blocked}/{value2.Count} stopped"));
					list.Add($"  {text} {Explain(item2.Key),-38} x{value2.Count,-5} {text2}");
				}
			}
			int totalSuppressed = Throttle.TotalSuppressed;
			if (totalSuppressed > 0)
			{
				list.Add($"({totalSuppressed} repeat(s) blocked without logging, to keep the server up)");
			}
			return list;
		}

		public static string Text()
		{
			return string.Join("\n", Lines());
		}

		public static void Reset()
		{
			_by.Clear();
			_names.Clear();
		}
	}
	internal static class Trace
	{
		public static readonly string[] Untargeted = new string[10] { "ClientSpokeToNpc", "GrillItemInLava", "InspectTool", "SelectInvSlot", "SendBoatInput", "SendFinishedTutorial", "SetIsAfk", "SetRadioFrequency", "UpdateDeadPlayerResurrectPercent", "UpdateRoulette" };

		public static readonly string[] Chatty = new string[9] { "PlayImpactSound", "ServerRelayFrame", "SetSyncedSimulator", "UpdateBaitPosAndLineLength", "UpdateHeldToolPosRot", "UpdateItemPosRot", "UpdatePlayerCrouching", "UpdatePlayerPosRot", "UpdateRodPullBack" };

		private static readonly Dictionary<string, int> _seen = new Dictionary<string, int>();

		private static readonly Dictionary<string, float> _lastLogged = new Dictionary<string, float>();

		private static int _attached;

		public static int Attached => _attached;

		public static int DistinctSeen => _seen.Count;

		private static IEnumerable<string> Everything()
		{
			return Targets.All.Select((Rpc t) => t.Name).Concat(Untargeted).Concat(Chatty)
				.Distinct();
		}

		public static void Install(Harmony h, Type server)
		{
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Expected O, but got Unknown
			IEnumerable<string> enumerable;
			if (!Plugin.TraceEverything.Value)
			{
				string[] untargeted = Untargeted;
				IEnumerable<string> second;
				if (!Plugin.TraceChatty.Value)
				{
					second = Enumerable.Empty<string>();
				}
				else
				{
					IEnumerable<string> chatty = Chatty;
					second = chatty;
				}
				enumerable = untargeted.Concat(second);
			}
			else
			{
				enumerable = Everything();
			}
			HarmonyMethod val = new HarmonyMethod(AccessTools.Method(typeof(Trace), "Tap", (Type[])null, (Type[])null));
			foreach (string item in enumerable)
			{
				try
				{
					MethodInfo methodInfo = Targets.Resolve(server, "RpcReader", item);
					if (!(methodInfo == null))
					{
						h.Patch((MethodBase)methodInfo, val, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
						_attached++;
					}
				}
				catch (Exception ex)
				{
					Plugin.Log.LogWarning((object)("[Trace] could not tap " + item + ": " + ex.Message));
				}
			}
			Plugin.Log.LogInfo((object)($"[Trace] tapped {_attached} unguarded RPCs " + (Plugin.TraceUnguarded.Value ? "(logging is ON)" : "(logging is off - /trace on)")));
		}

		public static void Tap(MethodBase __originalMethod, NetworkConnection __2)
		{
			if (!Plugin.TraceUnguarded.Value || !Plugin.IsHosting || Sender.IsTrusted(__2))
			{
				return;
			}
			try
			{
				string text = Short(__originalMethod.Name);
				string text2 = Sender.NameOf(__2);
				string key = text2 + ":" + text;
				if (Plugin.TraceEverything.Value)
				{
					Plugin.Log.LogInfo((object)("[Traffic] " + text2 + " -> " + text));
					_seen.TryGetValue(key, out var value);
					_seen[key] = value + 1;
					return;
				}
				_seen.TryGetValue(key, out var value2);
				_seen[key] = value2 + 1;
				float realtimeSinceStartup = Time.realtimeSinceStartup;
				if (!_lastLogged.TryGetValue(key, out var value3) || !(realtimeSinceStartup - value3 < Plugin.TraceInterval.Value))
				{
					_lastLogged[key] = realtimeSinceStartup;
					Plugin.Log.LogInfo((object)$"[Trace] {text2} -> {text}  (x{value2 + 1} so far, no rule for this one)");
				}
			}
			catch
			{
			}
		}

		private static string Short(string generated)
		{
			string[] array = generated.Split(new string[1] { "___" }, StringSplitOptions.RemoveEmptyEntries);
			if (array.Length < 2)
			{
				return generated;
			}
			return array[1];
		}

		public static string Summary()
		{
			if (_seen.Count == 0)
			{
				return "Trace: nothing seen on unguarded RPCs.";
			}
			List<string> list = new List<string> { "Unguarded RPCs used this session:" };
			foreach (KeyValuePair<string, int> item in _seen.OrderByDescending((KeyValuePair<string, int> k) => k.Value).Take(15))
			{
				list.Add($"   {item.Key}   x{item.Value}");
			}
			return string.Join("\n", list);
		}

		public static void Reset()
		{
			_seen.Clear();
			_lastLogged.Clear();
		}
	}
	internal static class Troll
	{
		private sealed class Mark
		{
			public float NextJostle;

			public float NextIdle;

			public float NextReact;

			public int Incidents;

			public int IdleLine;

			public string LastRule;
		}

		private static readonly Dictionary<ulong, Mark> _marked = new Dictionary<ulong, Mark>();

		private static int _pick;

		public static int Count => _marked.Count;

		public static IEnumerable<ulong> All => _marked.Keys;

		public static bool Is(ulong id)
		{
			return _marked.ContainsKey(id);
		}

		public static string Toggle(Player p)
		{
			if ((Object)(object)p == (Object)null)
			{
				return "Nobody by that name.";
			}
			ulong steamID;
			try
			{
				steamID = p.SteamID;
			}
			catch
			{
				return "Could not identify them.";
			}
			if (_marked.Remove(steamID))
			{
				Extras.Release(steamID);
				if (Plugin.TrollTaunts.Value)
				{
					Chat.Broadcast(string.Format(Pick(Hazing.Closing), p.SteamName));
				}
				return p.SteamName + " is off the hook.";
			}
			_marked[steamID] = new Mark
			{
				NextIdle = Time.realtimeSinceStartup + Plugin.TrollIdleInterval.Value
			};
			Extras.ApplyTrollEffects(steamID);
			if (Plugin.TrollTaunts.Value)
			{
				Chat.Broadcast(string.Format(Pick(Hazing.Opening), p.SteamName));
			}
			return p.SteamName + " is in troll mode: explodes when attacking, drops everything, earns nothing, gets shoved, and is being talked about.";
		}

		private static string Pick(string[] lines)
		{
			return lines[_pick++ % lines.Length];
		}

		public static void Clear()
		{
			foreach (ulong item in _marked.Keys.ToList())
			{
				Extras.Release(item);
			}
			_marked.Clear();
		}

		public static void Reacted(ulong id, string who, string rule)
		{
			if (rule == null || !_marked.TryGetValue(id, out var value) || !Plugin.TrollTaunts.Value)
			{
				return;
			}
			float realtimeSinceStartup = Time.realtimeSinceStartup;
			value.Incidents++;
			if ((!(rule == value.LastRule) || !(realtimeSinceStartup - value.NextReact < Plugin.TrollReactInterval.Value * 3f)) && !(realtimeSinceStartup < value.NextReact))
			{
				value.NextReact = realtimeSinceStartup + Plugin.TrollReactInterval.Value;
				value.LastRule = rule;
				if (Hazing.Reactions.TryGetValue(rule, out var value2))
				{
					Chat.Broadcast(string.Format(value2[value.Incidents % value2.Length], who));
					value.NextIdle = realtimeSinceStartup + Plugin.TrollIdleInterval.Value;
				}
			}
		}

		public static void Tick()
		{
			if (_marked.Count == 0 || !Plugin.IsHosting)
			{
				return;
			}
			float realtimeSinceStartup = Time.realtimeSinceStartup;
			try
			{
				foreach (Player player in PlayerManager.Players)
				{
					if ((Object)(object)player == (Object)null || (Object)(object)player == (Object)(object)Player.LocalPlayer)
					{
						continue;
					}
					ulong steamID;
					try
					{
						steamID = player.SteamID;
					}
					catch
					{
						continue;
					}
					if (_marked.TryGetValue(steamID, out var value))
					{
						if (realtimeSinceStartup >= value.NextJostle)
						{
							value.NextJostle = realtimeSinceStartup + Plugin.TrollJostleInterval.Value;
							Jostle(player);
						}
						if (Plugin.TrollTaunts.Value && realtimeSinceStartup >= value.NextIdle)
						{
							value.NextIdle = realtimeSinceStartup + Plugin.TrollIdleInterval.Value;
							Idle(player, value);
						}
					}
				}
			}
			catch
			{
			}
		}

		private static void Idle(Player p, Mark m)
		{
			int num = ((m.Incidents >= Plugin.TrollTier3.Value) ? 2 : ((m.Incidents >= Plugin.TrollTier2.Value) ? 1 : 0));
			string[] array = Hazing.Idle[num];
			Chat.Broadcast(string.Format(array[m.IdleLine++ % array.Length], p.SteamName, m.Incidents));
		}

		private static void Jostle(Player p)
		{
			//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_0046: 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_0048: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				Vector3 val = Body.Of(p);
				float value = Plugin.TrollJostleRadius.Value;
				float realtimeSinceStartup = Time.realtimeSinceStartup;
				Vector3 val2 = default(Vector3);
				((Vector3)(ref val2))..ctor(Mathf.Sin(realtimeSinceStartup * 3.1f) * value, 0f, Mathf.Cos(realtimeSinceStartup * 2.7f) * value);
				Server.Instance.TeleportPlayer(p, val + val2, 0f);
			}
			catch
			{
			}
		}
	}
	internal static class Tweaks
	{
		private static Vector2 _scroll;

		private static Vector2 _spawnScroll;

		public static void Draw()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//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)
			_scroll = GUILayout.BeginScrollView(_scroll, Array.Empty<GUILayoutOption>());
			Private();
			Theme.Rule();
			HostTools_();
			Theme.Rule();
			Fixes();
			GUILayout.EndScrollView();
		}

		private static void Private()
		{
			//IL_0148: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c6: 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_01e3: 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)
			Theme.Header("PRIVATE  —  NOT IN THE PUBLIC BUILD");
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			if (Toggle(Cheats.Immortal, "Oops I Did It Again", 150))
			{
				Cheats.Immortal = !Cheats.Immortal;
			}
			if (Toggle(Cheats.InfiniteAmmo, "Endless ammo", 140))
			{
				Cheats.InfiniteAmmo = !Cheats.InfiniteAmmo;
			}
			GUILayout.EndHorizontal();
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			if (Toggle(Cheats.OnePunch, "One punch", 110))
			{
				Cheats.OnePunch = !Cheats.OnePunch;
			}
			if (Toggle(Cheats.Stretchy, "Mr. Fantastic", 120))
			{
				Cheats.Stretchy = !Cheats.Stretchy;
			}
			if (Toggle(Cheats.WalkOnWater, "Jesus mode", 120))
			{
				Cheats.WalkOnWater = !Cheats.WalkOnWater;
			}
			GUILayout.EndHorizontal();
			if (Cheats.Stretchy)
			{
				Dial("Fantastic reach", ref Cheats.Reach, 2f, 60f);
			}
			Dial("Money", ref Cheats.MoneyMultiplier, 1f, 50f);
			Dial("Luck", ref Cheats.LuckMultiplier, 1f, 20f);
			Dial("Speed", ref Cheats.SpeedMultiplier, 1f, 20f);
			GUILayout.Space(4f);
			Theme.Line("SPAWN", Theme.Muted, 12);
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			Cheats.Filter = GUILayout.TextField(Cheats.Filter, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(24f) });
			if (GUILayout.Button("clear", (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.Width(60f),
				GUILayout.Height(24f)
			}))
			{
				Cheats.Filter = "";
			}
			GUILayout.EndHorizontal();
			List<string> list = Cheats.Names(Cheats.Filter);
			_spawnScroll = GUILayout.BeginScrollView(_spawnScroll, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(130f) });
			foreach (string item in list.Take(60))
			{
				if (GUILayout.Button(item, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(22f) }))
				{
					Toast(Cheats.Spawn(item));
				}
			}
			if (list.Count > 60)
			{
				Theme.Line($"...{list.Count - 60} more - narrow the search", Theme.Faint, 11);
			}
			GUILayout.EndScrollView();
		}

		private static void Dial(string label, ref float value, float min, float max)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: 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)
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			Theme.Line(label, Theme.Muted, 12);
			GUILayout.FlexibleSpace();
			Theme.Line("x" + value.ToString("0.0"), (value > 1.001f) ? Theme.Warn : Theme.Muted, 12);
			if (GUILayout.Button("off", (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.Width(40f),
				GUILayout.Height(18f)
			}))
			{
				value = 1f;
			}
			GUILayout.EndHorizontal();
			value = GUILayout.HorizontalSlider(value, min, max, Array.Empty<GUILayoutOption>());
			GUILayout.Space(2f);
		}

		private static void Fixes()
		{
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			Theme.Header("VANILLA BUG FIXES");
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			if (Toggle(Plugin.FixJoining.Value, "Black screen on join", 190))
			{
				Plugin.FixJoining.Value = !Plugin.FixJoining.Value;
			}
			if (Toggle(Plugin.PruneBrokenPlayers.Value, "Sinking boat", 140))
			{
				Plugin.PruneBrokenPlayers.Value = !Plugin.PruneBrokenPlayers.Value;
			}
			GUILayout.EndHorizontal();
			Theme.Line("Both are bugs in the base game. Leave them on.", Theme.Faint, 11);
			Theme.Header("INTERFACE");
			if (Toggle(Plugin.NativeConsole.Value, "Rebuild this from the game's menu", 300))
			{
				Plugin.NativeConsole.Value = !Plugin.NativeConsole.Value;
				Dashboard.Toast(Plugin.NativeConsole.Value ? "Close and reopen F4 to see it. Turn this off to come straight back." : "Back to this one. Reopen F4.");
			}
			Theme.Line("Unfinished. This one works; that one is where it is going.", Theme.Faint, 11);
		}

		private static void HostTools_()
		{
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			Theme.Header("YOUR TOOLS");
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			if (Toggle(HostTools.Flying, HostTools.Flying ? "Flying" : "Fly", 90))
			{
				Toast(HostTools.ToggleFly());
			}
			if (GUILayout.Button("< Island", (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.Width(80f),
				GUILayout.Height(26f)
			}))
			{
				Toast(HostTools.Next(backwards: true));
			}
			if (GUILayout.Button("Island >", (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.Width(80f),
				GUILayout.Height(26f)
			}))
			{
				Toast(HostTools.Next(backwards: false));
			}
			GUILayout.FlexibleSpace();
			Theme.Line(HostTools.Where(), Theme.Muted, 12);
			GUILayout.EndHorizontal();
			Slider("Fly speed", Plugin.FlySpeed, 5f, 80f, "0");
			Slider("Shift boost", Plugin.FlyBoost, 1f, 10f, "0.0");
		}

		private static bool Toggle(bool on, string label, int width)
		{
			//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_0033: 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_0074: Unknown result type (might be due to invalid IL or missing references)
			Color backgroundColor = GUI.backgroundColor;
			GUI.backgroundColor = (on ? new Color(0.3f, 0.62f, 0.82f) : new Color(1f, 1f, 1f, 0.1f));
			bool result = GUILayout.Button((on ? "✓  " : "     ") + label, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.Width((float)width),
				GUILayout.Height(26f)
			});
			GUI.backgroundColor = backgroundColor;
			return result;
		}

		private static void Slider(string label, ConfigEntry<float> cfg, float min, float max, string fmt)
		{
			//IL_000b: 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)
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			Theme.Line(label, Theme.Muted, 12);
			GUILayout.FlexibleSpace();
			Theme.Line(cfg.Value.ToString(fmt), Theme.Ink, 12);
			GUILayout.EndHorizontal();
			float num = GUILayout.HorizontalSlider(cfg.Value, min, max, Array.Empty<GUILayoutOption>());
			if (Mathf.Abs(num - cfg.Value) > 0.0001f)
			{
				cfg.Value = num;
			}
			GUILayout.Space(2f);
		}

		private static void IntSlider(string label, ConfigEntry<int> cfg, int min, int max)
		{
			//IL_000b: 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)
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			Theme.Line(label, Theme.Muted, 12);
			GUILayout.FlexibleSpace();
			Theme.Line(cfg.Value.ToString(), Theme.Ink, 12);
			GUILayout.EndHorizontal();
			int num = Mathf.RoundToInt(GUILayout.HorizontalSlider((float)cfg.Value, (float)min, (float)max, Array.Empty<GUILayoutOption>()));
			if (num != cfg.Value)
			{
				cfg.Value = num;
			}
			GUILayout.Space(2f);
		}

		private static void Toast(string msg)
		{
			Dashboard.Toast(msg);
		}
	}
	public enum Confidence
	{
		Clean,
		Contextual,
		Strong,
		Certain
	}
	public readonly struct Verdict
	{
		public readonly Confidence Confidence;

		public readonly string Rule;

		public readonly string Detail;

		public static readonly Verdict Clean = new Verdict(Confidence.Clean, null, null);

		public bool IsHostile => Confidence != Confidence.Clean;

		public int StrikeWeight => Confidence switch
		{
			Confidence.Certain => 10, 
			Confidence.Strong => 3, 
			Confidence.Contextual => 1, 
			_ => 0, 
		};

		public string Tag => Confidence switch
		{
			Confidence.Certain => "CERTAIN", 
			Confidence.Strong => "strong", 
			Confidence.Contextual => "maybe", 
			_ => "clean", 
		};

		private Verdict(Confidence c, string rule, string detail)
		{
			Confidence = c;
			Rule = rule;
			Detail = detail;
		}

		public static Verdict Certain(string rule, string detail)
		{
			return new Verdict(Confidence.Certain, rule, detail);
		}

		public static Verdict Strong(string rule, string detail)
		{
			return new Verdict(Confidence.Strong, rule, detail);
		}

		public static Verdict Contextual(string rule, string detail)
		{
			return new Verdict(Confidence.Contextual, rule, detail);
		}
	}
	internal static class VoiceGuard
	{
		public static bool Relay_Pre()
		{
			return Actions.VoiceFrame(Sender.Current);
		}
	}
	internal static class Weapons
	{
		private static readonly Dictionary<object, int> _meleeMax = new Dictionary<object, int>();

		private static int _punchMax = -1;

		private static bool _punchWasRead;

		private static float _headshot = -1f;

		private static float _pvpScale = -1f;

		public static bool LastWasRead { get; private set; }

		public static int ExpectedMax(Player attacker)
		{
			return ExpectedMax(attacker, bareHandsBound: true);
		}

		public static int ExpectedMax(Player attacker, bool bareHandsBound)
		{
			LastWasRead = false;
			if ((Object)(object)attacker == (Object)null)
			{
				return -1;
			}
			try
			{
				Item val = (((Object)(object)attacker.Holding != (Object)null) ? attacker.Holding.HeldItem : null);
				if ((Object)(object)val != (Object)null)
				{
					Weapon weapon = val.Weapon;
					if ((Object)(object)weapon != (Object)null)
					{
						LastWasRead = true;
						return Math.Max(weapon.Damage, ProjectileFloor());
					}
					Melee melee = val.Melee;
					if ((Object)(object)melee != (Object)null)
					{
						int num = MeleeMax(melee);
						if (num > 0)
						{
							LastWasRead = true;
							return num;
						}
					}
					_ = (Object)(object)val.Explosive != (Object)null;
					return -1;
				}
				return bareHandsBound ? PunchMax(attacker) : (-1);
			}
			catch
			{
				return -1;
			}
		}

		private static int MeleeMax(object melee)
		{
			if (_meleeMax.TryGetValue(melee, out var value))
			{
				return value;
			}
			int num = -1;
			try
			{
				if (Traverse.Create(melee).Field("_sharpnessUpgrades").GetValue() is IEnumerable enumerable)
				{
					foreach (object item in enumerable)
					{
						if (item != null)
						{
							Traverse val = Traverse.Create(item).Property("Damage", (object[])null);
							int num2 = ((val != null && val.PropertyExists()) ? val.GetValue<int>() : Traverse.Create(item).Field("_damage").GetValue<int>());
							if (num2 > num)
							{
								num = num2;
							}
						}
					}
				}
			}
			catch
			{
			}
			if (_meleeMax.Count > 128)
			{
				_meleeMax.Clear();
			}
			_meleeMax[melee] = num;
			return num;
		}

		private static int PunchMax(Player attacker)
		{
			if (_punchMax > 0)
			{
				LastWasRead = _punchWasRead;
				return _punchMax;
			}
			try
			{
				PlayerPunching punching = attacker.Punching;
				if ((Object)(object)punching != (Object)null)
				{
					Traverse val = Traverse.Create((object)punching).Field("_damage");
					if (val != null && val.FieldExists())
					{
						int value = val.GetValue<int>();
						if (value > 0)
						{
							_punchMax = value;
							_punchWasRead = true;
							return value;
						}
					}
				}
			}
			catch
			{
			}
			return Plugin.AssumedPunchDamage.Value;
		}

		private static int ProjectileFloor()
		{
			return Plugin.MinimumDamageCeiling.Value;
		}

		public static float CreatureScale()
		{
			if (_headshot > 0f)
			{
				return _headshot;
			}
			try
			{
				Traverse val = Traverse.Create(typeof(GameInfo)).Property("HeadShotDamageMulti", (object[])null);
				if (val != null && val.PropertyExists())
				{
					float value = val.GetValue<float>();
					if (value > 1f)
					{
						_headshot = value;
						Plugin.Log.LogInfo((object)("[Weapons] headshots multiply creature damage by " + $"{value} - read from the game."));
						return value;
					}
				}
			}
			catch
			{
			}
			_headshot = Math.Max(1f, Plugin.AssumedHeadshotMulti.Value);
			Plugin.Log.LogWarning((object)("[Weapons] could not read HeadShotDamageMulti - assuming " + $"{_headshot}. Creature damage ceilings are a guess until " + "this reads properly."));
			return _headshot;
		}

		public static float PlayerDamageScale(Player victim)
		{
			if (_pvpScale > 0f)
			{
				return _pvpScale;
			}
			try
			{
				PlayerVitals val = (((Object)(object)victim != (Object)null) ? victim.Vitals : null);
				if ((Object)(object)val != (Object)null)
				{
					Traverse val2 = Traverse.Create((object)val).Field("_playerDamageMultiplier");
					if (val2 != null && val2.FieldExists())
					{
						float value = val2.GetValue<float>();
						if (value > 0f)
						{
							_pvpScale = value;
							return value;
						}
					}
				}
			}
			catch
			{
			}
			return Plugin.AssumedPvpScale.Value;
		}

		public static bool IsImpossible(Player attacker, int claimed, out int ceiling, out string what)
		{
			return IsImpossible(attacker, claimed, 1f, out ceiling, out what);
		}

		public static bool IsImpossible(Player attacker, int claimed, float scale, out int ceiling, out string what)
		{
			return IsImpossible(attacker, claimed, scale, bareHandsBound: true, out ceiling, out what);
		}

		public static bool IsImpossible(Player attacker, int claimed, float scale, bool bareHandsBound, out int ceiling, out string what)
		{
			ceiling = -1;
			what = null;
			int num = ExpectedMax(attacker, bareHandsBound);
			if (num <= 0)
			{
				return false;
			}
			bool lastWasRead = LastWasRead;
			ceiling = (int)((float)num * Math.Max(0.01f, scale) * Math.Max(1f, Plugin.DamageTolerance.Value));
			if (!lastWasRead)
			{
				ceiling = Math.Max(ceiling, (int)((float)Plugin.MinimumDamageCeiling.Value * Math.Max(0.01f, scale)));
			}
			if (ceiling < 1)
			{
				ceiling = 1;
			}
			if (claimed <= ceiling)
			{
				return false;
			}
			try
			{
				Item val = (((Object)(object)attacker.Holding != (Object)null) ? attacker.Holding.HeldItem : null);
				what = (((Object)(object)val == (Object)null) ? "their fists" : (((Object)val).name ?? "what they hold").Replace("(Clone)", "").Trim());
			}
			catch
			{
				what = "what they hold";
			}
			return true;
		}
	}
	internal static class WheelGuard
	{
		private static readonly string[] Swallowed = new string[4] { "ScrollSlotInput", "SelectSlotInput", "ScrollInput", "ScrollJournalInput" };

		private static readonly string[] Zeroed = new string[3] { "LookInput", "HorizontalInput", "CanLookAround" };

		public static void Install(Harmony h)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Expected O, but got Unknown
			//IL_016c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0173: Expected O, but got Unknown
			//IL_0189: Unknown result type (might be due to invalid IL or missing references)
			//IL_0190: Expected O, but got Unknown
			//IL_01a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ad: Expected O, but got Unknown
			HarmonyMethod val = new HarmonyMethod(AccessTools.Method(typeof(WheelGuard), "Closed", (Type[])null, (Type[])null));
			List<string> list = new List<string>();
			try
			{
				Type[] types;
				try
				{
					types = typeof(Player).Assembly.GetTypes();
				}
				catch (ReflectionTypeLoadException ex)
				{
					types = ex.Types;
				}
				Type[] array = types;
				foreach (Type type in array)
				{
					if (Skip(type))
					{
						continue;
					}
					string[] swallowed = Swallowed;
					foreach (string text in swallowed)
					{
						MethodInfo methodInfo = AccessTools.Method(type, text, (Type[])null, (Type[])null);
						if (!(methodInfo == null) && !methodInfo.IsAbstract && !methodInfo.ContainsGenericParameters)
						{
							try
							{
								h.Patch((MethodBase)methodInfo, val, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
								list.Add(type.Name + "." + text);
							}
							catch (Exception ex2)
							{
								Plugin.Log.LogWarning((object)("[WheelGuard] could not hold " + type.Name + "." + text + ": " + ex2.Message));
							}
						}
					}
				}
			}
			catch (Exception ex3)
			{
				Plugin.Log.LogError((object)("[WheelGuard] unavailable: " + ex3.Message));
			}
			try
			{
				HarmonyMethod val2 = new HarmonyMethod(AccessTools.Method(typeof(WheelGuard), "ZeroVector", (Type[])null, (Type[])null));
				HarmonyMethod val3 = new HarmonyMethod(AccessTools.Method(typeof(WheelGuard), "ZeroFloat", (Type[])null, (Type[])null));
				HarmonyMethod val4 = new HarmonyMethod(AccessTools.Method(typeof(WheelGuard), "ZeroBool", (Type[])null, (Type[])null));
				Type[] types2;
				try
				{
					types2 = typeof(Player).Assembly.GetTypes();
				}
				catch (ReflectionTypeLoadException ex4)
				{
					types2 = ex4.Types;
				}
				Type[] array = types2;
				foreach (Type type2 in array)
				{
					if (Skip(type2))
					{
						continue;
					}
					string[] swallowed = Zeroed;
					foreach (string text2 in swallowed)
					{
						PropertyInfo propertyInfo = AccessTools.Property(type2, text2);
						if (propertyInfo == null)
						{
							continue;
						}
						MethodInfo getMethod = propertyInfo.GetGetMethod(nonPublic: true);
						if (getMethod == null || getMethod.IsAbstract)
						{
							Plugin.Log.LogWarning((object)("[WheelGuard] " + type2.Name + "." + text2 + " has no getter to hold."));
							continue;
						}
						HarmonyMethod val5 = ((propertyInfo.PropertyType == typeof(Vector2)) ? val2 : ((propertyInfo.PropertyType == typeof(float)) ? val3 : ((propertyInfo.PropertyType == typeof(bool)) ? val4 : null)));
						if (val5 == null)
						{
							Plugin.Log.LogWarning((object)("[WheelGuard] " + type2.Name + "." + text2 + " is a " + propertyInfo.PropertyType.Name + ", which nothing here knows how to zero."));
							continue;
						}
						try
						{
							h.Patch((MethodBase)getMethod, (HarmonyMethod)null, val5, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
							list.Add(type2.Name + "." + text2);
						}
						catch (Exception ex5)
						{
							Plugin.Log.LogWarning((object)("[WheelGuard] could not zero " + type2.Name + "." + text2 + ": " + ex5.Message));
						}
					}
				}
			}
			catch (Exception ex6)
			{
				Plugin.Log.LogError((object)("[WheelGuard] input zeroing unavailable: " + ex6.Message));
			}
			if (list.Count == 0)
			{
				Plugin.Log.LogWarning((object)"[WheelGuard] found nothing to hold - the wheel and the camera will still work while the console is open.");
			}
			else
			{
				Plugin.Log.LogInfo((object)("[WheelGuard] held while the console is open: " + string.Join(", ", list.ToArray())));
			}
			foreach (string name in Swallowed.Concat(Zeroed))
			{
				if (!list.Any((string c) => c.EndsWith("." + name, StringComparison.Ordinal)))
				{
					Plugin.Log.LogWarning((object)("[WheelGuard] no method called " + name + " - whatever it did still happens while the console is open."));
				}
			}
		}

		private static void ZeroVector(ref Vector2 __result)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			if (Open())
			{
				__result = Vector2.zero;
			}
		}

		private static void ZeroFloat(ref float __result)
		{
			if (Open())
			{
				__result = 0f;
			}
		}

		private static void ZeroBool(ref bool __result)
		{
			if (Open())
			{
				__result = false;
			}
		}

		private static bool Open()
		{
			try
			{
				return Dashboard.IsOpen;
			}
			catch
			{
				return false;
			}
		}

		private static bool Skip(Type t)
		{
			if (t == null)
			{
				return true;
			}
			if (t.IsNested)
			{
				return true;
			}
			return t.Name.IndexOf('<') >= 0;
		}

		private static bool Closed()
		{
			try
			{
				return !Dashboard.IsOpen;
			}
			catch
			{
				return true;
			}
		}
	}
	internal static class Worths
	{
		private static float _high;

		private static int _count;

		private static float _nextReport;

		private static readonly Dictionary<string, float> _itemAt = new Dictionary<string, float>();

		private static readonly Dictionary<string, int> _perItem = new Dictionary<string, int>();

		private static readonly Dictionary<ulong, int> _perPlayer = new Dictionary<ulong, int>();

		private static float _minute;

		public static string Abusing(ulong who, Item item)
		{
			//IL_0045: 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)
			float realtimeSinceStartup = Time.realtimeSinceStartup;
			if (realtimeSinceStartup >= _minute)
			{
				_minute = realtimeSinceStartup + 60f;
				_perPlayer.Clear();
				_perItem.Clear();
				_itemAt.Clear();
			}
			if ((Object)(object)item != (Object)null)
			{
				string key = ((object)((Object)item).GetEntityId()/*cast due to .constrained prefix*/).ToString();
				float value;
				bool num = _itemAt.TryGetValue(key, out value);
				_itemAt[key] = realtimeSinceStartup;
				if (num && realtimeSinceStartup - value >= Plugin.WorthRepeatGrace.Value)
				{
					_perItem.TryGetValue(key, out var value2);
					_perItem[key] = value2 + 1;
					return $"set the sell value on {((Object)item).name} again ({value2 + 2} times, " + $"{realtimeSinceStartup - value:0.0}s after the last one)";
				}
			}
			_perPlayer.TryGetValue(who, out var value3);
			value3++;
			_perPlayer[who] = value3;
			int num2 = ((Plugin.WorthsPerMinute != null) ? Plugin.WorthsPerMinute.Value : 0);
			if (num2 > 0 && value3 > num2)
			{
				return $"set sell values {value3} times in a minute";
			}
			return null;
		}

		public static void Saw(float multiplier)
		{
			_count++;
			if (multiplier > _high)
			{
				_high = multiplier;
			}
			float realtimeSinceStartup = Time.realtimeSinceStartup;
			if (!(realtimeSinceStartup < _nextReport))
			{
				_nextReport = realtimeSinceStartup + 60f;
				Plugin.Log.LogInfo((object)($"[Worths] {_count} multiplier(s) so far, highest x{_high:0.0}. " + "If honest play is reaching the ceiling, this is the number to raise Guard/MaxWorthMultiplier to."));
			}
		}

		public static string Seen()
		{
			if (_count != 0)
			{
				return $"highest seen this session x{_high:0.0}";
			}
			return "nothing else seen yet";
		}
	}
}