using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using BoneLib.BoneMenu;
using BoneLib.Notifications;
using FusionReborn;
using HarmonyLib;
using Il2CppInterop.Runtime.InteropTypes.Arrays;
using Il2CppSLZ.Marrow;
using Il2CppSLZ.Marrow.Pool;
using LabFusion.Data;
using LabFusion.Downloading.ModIO;
using LabFusion.Entities;
using LabFusion.Marrow.Pool;
using LabFusion.Marrow.Serialization;
using LabFusion.Network;
using LabFusion.Network.Serialization;
using LabFusion.Permissions;
using LabFusion.Player;
using LabFusion.RPC;
using LabFusion.Representation;
using LabFusion.SDK.Lobbies;
using LabFusion.SDK.Modules;
using LabFusion.Senders;
using LabFusion.Utilities;
using MelonLoader;
using MelonLoader.Preferences;
using Microsoft.CodeAnalysis;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: MelonInfo(typeof(Reborn), "Fusion: Reborn", "1.0.0", "Gerf.", null)]
[assembly: MelonGame("Stress Level Zero", "BONELAB")]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = ".NET 6.0")]
[assembly: AssemblyCompany("Gerf.")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("Fusion: Reborn")]
[assembly: AssemblyTitle("FusionReborn")]
[assembly: AssemblyVersion("1.0.0.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace FusionReborn
{
	public class Reborn : MelonMod
	{
		public static Reborn Instance { get; private set; }

		public override void OnInitializeMelon()
		{
			//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)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Expected O, but got Unknown
			//IL_0026: Expected O, but got Unknown
			Instance = this;
			RebornConfig.Load();
			Harmony val = new Harmony("com.gerf.fusionreborn");
			val.PatchAll();
			NetworkSpawnPermissionGuard.TryPatch(val);
			NetworkSpawnBarcodeGuard.TryPatch(val);
			ModuleManager.RegisterModule<RebornNetModule>();
			ModuleMessageManager.RegisterHandler<PresenceMessageHandler>();
			ModuleMessageManager.RegisterHandler<VitalityAlertMessageHandler>();
			ModuleMessageManager.RegisterHandler<FlyhackAlertMessageHandler>();
			HostSync.Initialize();
			ObjectSpawnGuard.Initialize();
			FlyhackGuard.Initialize();
			VitalityGuard.Initialize();
			ModioGuard.Initialize();
			ServerHider.Initialize();
			PanicKick.Initialize();
			DespawnAllLoop.Initialize();
			AutoVolumeLimiter.Initialize();
			EmissionBloomGuard.Initialize();
			SceneObjectCapGuard.Initialize();
			RebornMenu.Setup();
		}

		public override void OnUpdate()
		{
			PlayerGuardTick.Tick();
			PanicKick.Tick();
			DespawnAllLoop.Tick();
			AutoVolumeLimiter.Tick();
		}

		public override void OnDeinitializeMelon()
		{
			RebornConfig.Save();
		}
	}
	public static class RebornConfig
	{
		public static readonly List<string> DefaultBlockedSpawnables = new List<string> { "stayx.weaponpack.Spawnable.NuclearBomb", "Cancer.Test.Spawnable.Test", "stayx.weaponpack.Spawnable.BigExplosion", "BaBaCorp.MiscExplosiveDevices.Spawnable.Missile", "BaBaCorp.MiscExplosiveDevices.Spawnable.ExplosionMissile", "BaBaCorp.MiscExplosiveDevices.Spawnable.MiniMissile", "BaBaCorp.MiscExplosiveDevices.Spawnable.IncinMissile", "BaBaCorp.MiscExplosiveDevices.Spawnable.ExplosionFlameMissile", "BaBaCorp.MiscExplosiveDevices.Spawnable.ExplosionDivineLight", "BaBaCorp.MiscExplosiveDevices.Spawnable.KCB4VoidTunnelingDevice" };

		public static readonly List<string> DefaultAmmoBarcodeKeywords = new List<string> { "ammo", "bullet", "cartridge", "casing", "shellcasing", "shell", "round" };

		public static readonly List<string> DefaultBlockedModioProfiles = new List<string> { "6ixleafclover", "Kozmo_123", "fracturedterps", "E7huzzALT", "E7huzz", "Fraud33", "SoopSaw", "Milonthevr" };

		public static float FuzzyNameSimilarityThreshold = 0.82f;

		public static readonly List<string> DefaultServerHideCodewords = new List<string>
		{
			"Hood", "hood", "rus", "Rus", "russian", "Russian", "Pol", "pol", "poland", "Poland",
			"ukr", "Ukr", "Ukraine", "ukraine"
		};

		public const float VitalityHardCapThreshold = 1000f;

		public static HashSet<string> BlockedSpawnables = new HashSet<string>();

		public static HashSet<string> BlockedModioProfiles = new HashSet<string>();

		public static HashSet<string> ServerHideCodewords = new HashSet<string>();

		public static HashSet<string> AmmoBarcodeKeywords = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

		public static MelonPreferences_Category Category;

		public static MelonPreferences_Entry<bool> ObjectSpawnGuardEnabled;

		public static MelonPreferences_Entry<bool> FlyhackGuardEnabled;

		public static MelonPreferences_Entry<bool> VitalityGuardEnabled;

		public static MelonPreferences_Entry<bool> KickOnInfiniteVitality;

		public static MelonPreferences_Entry<bool> RestrictNetworkedSpawningToOperators;

		public static MelonPreferences_Entry<bool> ModBlacklistEnabled;

		public static MelonPreferences_Entry<bool> ServerHidingEnabled;

		public static MelonPreferences_Entry<bool> PanicKickEnabled;

		public static MelonPreferences_Entry<KeyCode> PanicKickKey;

		public static MelonPreferences_Entry<bool> DespawnAllKeyEnabled;

		public static MelonPreferences_Entry<KeyCode> DespawnAllKey;

		public static MelonPreferences_Entry<int> MaxSceneObjects;

		public static MelonPreferences_Entry<bool> AutoVolumeLimiterEnabled;

		public static MelonPreferences_Entry<float> AutoVolumeLoudnessThreshold;

		public static MelonPreferences_Entry<float> AutoVolumeMaxReduction;

		public static MelonPreferences_Entry<bool> EmissionBloomGuardEnabled;

		public static MelonPreferences_Entry<float> EmissionIntensityThreshold;

		public static MelonPreferences_Entry<float> MaxAllowedSpeed;

		public static void Load()
		{
			Category = MelonPreferences.CreateCategory("FusionReborn");
			ObjectSpawnGuardEnabled = Category.CreateEntry<bool>("ObjectSpawnGuardEnabled", true, "Block Greifing Items", (string)null, false, false, (ValueValidator)null, (string)null);
			FlyhackGuardEnabled = Category.CreateEntry<bool>("FlyhackGuardEnabled", true, "Flyhack Detection", (string)null, false, false, (ValueValidator)null, (string)null);
			VitalityGuardEnabled = Category.CreateEntry<bool>("VitalityGuardEnabled", true, "Infinite Health Detection", (string)null, false, false, (ValueValidator)null, (string)null);
			KickOnInfiniteVitality = Category.CreateEntry<bool>("KickOnInfiniteVitality", true, "Kick on Infinite Health", (string)null, false, false, (ValueValidator)null, (string)null);
			RestrictNetworkedSpawningToOperators = Category.CreateEntry<bool>("RestrictNetworkedSpawningToOperators", false, "Block Spawn Requests", (string)null, false, false, (ValueValidator)null, (string)null);
			MaxAllowedSpeed = Category.CreateEntry<float>("MaxAllowedSpeed", 40f, "Max Allowed Player Speed (u/s)", (string)null, false, false, (ValueValidator)null, (string)null);
			ModBlacklistEnabled = Category.CreateEntry<bool>("ModBlacklistEnabled", false, "Hide Hood Avatars", (string)null, false, false, (ValueValidator)null, (string)null);
			ServerHidingEnabled = Category.CreateEntry<bool>("ServerHidingEnabled", false, "Hide Hood & Racist Servers", (string)null, false, false, (ValueValidator)null, (string)null);
			PanicKickEnabled = Category.CreateEntry<bool>("PanicKickEnabled", true, "Enable Panic Kick Key", (string)null, false, false, (ValueValidator)null, (string)null);
			PanicKickKey = Category.CreateEntry<KeyCode>("PanicKickKey", (KeyCode)290, "Panic Kick All Key", (string)null, false, false, (ValueValidator)null, (string)null);
			DespawnAllKeyEnabled = Category.CreateEntry<bool>("DespawnAllKeyEnabled", true, "Despawn All Key Enabled", (string)null, false, false, (ValueValidator)null, (string)null);
			DespawnAllKey = Category.CreateEntry<KeyCode>("DespawnAllKey", (KeyCode)289, "Despawn All Key", (string)null, false, false, (ValueValidator)null, (string)null);
			MaxSceneObjects = Category.CreateEntry<int>("MaxSceneObjects", 300, "Max Scene Objects", (string)null, false, false, (ValueValidator)null, (string)null);
			AutoVolumeLimiterEnabled = Category.CreateEntry<bool>("AutoVolumeLimiterEnabled", true, "Auto Volume Limiter", (string)null, false, false, (ValueValidator)null, (string)null);
			AutoVolumeLoudnessThreshold = Category.CreateEntry<float>("AutoVolumeLoudnessThreshold", -10f, "Loudness Threshold (dB)", (string)null, false, false, (ValueValidator)null, (string)null);
			AutoVolumeMaxReduction = Category.CreateEntry<float>("AutoVolumeMaxReduction", 0.6f, "Max Volume Reduction", (string)null, false, false, (ValueValidator)null, (string)null);
			EmissionBloomGuardEnabled = Category.CreateEntry<bool>("EmissionBloomGuardEnabled", true, "Disable Overbright Emission", (string)null, false, false, (ValueValidator)null, (string)null);
			EmissionIntensityThreshold = Category.CreateEntry<float>("EmissionIntensityThreshold", 5f, "Emission Intensity Threshold", (string)null, false, false, (ValueValidator)null, (string)null);
			BlockedSpawnables = new HashSet<string>(DefaultBlockedSpawnables);
			BlockedModioProfiles = new HashSet<string>(DefaultBlockedModioProfiles);
			ServerHideCodewords = new HashSet<string>(DefaultServerHideCodewords, StringComparer.OrdinalIgnoreCase);
			AmmoBarcodeKeywords = new HashSet<string>(DefaultAmmoBarcodeKeywords, StringComparer.OrdinalIgnoreCase);
		}

		public static void Save()
		{
			MelonPreferences_Category category = Category;
			if (category != null)
			{
				category.SaveToFile(false);
			}
		}
	}
	public class RebornNetModule : Module
	{
		public override string Name => "Fusion: Reborn";

		public override string Author => "Gerf.";

		public override Version Version => new Version(1, 0, 0);

		public override ConsoleColor Color => ConsoleColor.Red;

		protected override void OnModuleRegistered()
		{
		}
	}
	public class PresenceMessageHandler : ModuleMessageHandler
	{
		protected override void OnHandleMessage(ReceivedMessage received)
		{
			NetReader val = NetReader.Create(((ReceivedMessage)(ref received)).Bytes);
			try
			{
				if (val.ReadByte() == 1 && ((ReceivedMessage)(ref received)).Sender == 0)
				{
					HostSync.OnPresenceReceivedFromHost();
				}
			}
			finally
			{
				((IDisposable)val)?.Dispose();
			}
		}
	}
	public class VitalityAlertMessageHandler : ModuleMessageHandler
	{
		protected override void OnHandleMessage(ReceivedMessage received)
		{
			if (!NetworkInfo.IsHost)
			{
				return;
			}
			NetReader val = NetReader.Create(((ReceivedMessage)(ref received)).Bytes);
			try
			{
				string title = val.ReadString();
				string message = val.ReadString();
				VitalityGuard.OnVitalityAlertReceived(title, message);
			}
			finally
			{
				((IDisposable)val)?.Dispose();
			}
		}
	}
	public class FlyhackAlertMessageHandler : ModuleMessageHandler
	{
		protected override void OnHandleMessage(ReceivedMessage received)
		{
			if (!NetworkInfo.IsHost)
			{
				return;
			}
			NetReader val = NetReader.Create(((ReceivedMessage)(ref received)).Bytes);
			try
			{
				string title = val.ReadString();
				string message = val.ReadString();
				FlyhackGuard.OnFlyhackAlertReceived(title, message);
			}
			finally
			{
				((IDisposable)val)?.Dispose();
			}
		}
	}
	public static class HostSync
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static ServerEvent <0>__OnJoinedServer;

			public static PlayerUpdate <1>__OnPlayerJoined;

			public static ServerEvent <2>__OnDisconnected;
		}

		public static bool HostHasReborn { get; private set; }

		public static bool HostEnforcementActive
		{
			get
			{
				if (NetworkInfo.HasServer)
				{
					return HostHasReborn;
				}
				return false;
			}
		}

		public static void Initialize()
		{
			//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)
			//IL_001b: Expected O, but got Unknown
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Expected O, but got Unknown
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Expected O, but got Unknown
			object obj = <>O.<0>__OnJoinedServer;
			if (obj == null)
			{
				ServerEvent val = OnJoinedServer;
				<>O.<0>__OnJoinedServer = val;
				obj = (object)val;
			}
			MultiplayerHooking.OnJoinedServer += (ServerEvent)obj;
			object obj2 = <>O.<1>__OnPlayerJoined;
			if (obj2 == null)
			{
				PlayerUpdate val2 = OnPlayerJoined;
				<>O.<1>__OnPlayerJoined = val2;
				obj2 = (object)val2;
			}
			MultiplayerHooking.OnPlayerJoined += (PlayerUpdate)obj2;
			object obj3 = <>O.<2>__OnDisconnected;
			if (obj3 == null)
			{
				ServerEvent val3 = OnDisconnected;
				<>O.<2>__OnDisconnected = val3;
				obj3 = (object)val3;
			}
			MultiplayerHooking.OnDisconnected += (ServerEvent)obj3;
		}

		private static void OnJoinedServer()
		{
			HostHasReborn = false;
			BroadcastPresence();
		}

		private static void OnPlayerJoined(PlayerID player)
		{
			BroadcastPresence();
		}

		private static void OnDisconnected()
		{
			HostHasReborn = false;
		}

		private static void BroadcastPresence()
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				NetWriter val = NetWriter.Create();
				try
				{
					val.Write((byte)1);
					NetMessage val2 = NetMessage.ModuleCreate(typeof(PresenceMessageHandler), val, CommonMessageRoutes.ReliableToServer, (byte?)PlayerIDManager.LocalSmallID);
					try
					{
						MessageSender.SendToServer((NetworkChannel)0, val2);
						if (NetworkInfo.IsHost)
						{
							HostHasReborn = true;
						}
					}
					finally
					{
						((IDisposable)val2)?.Dispose();
					}
				}
				finally
				{
					((IDisposable)val)?.Dispose();
				}
			}
			catch (Exception)
			{
			}
		}

		public static void OnPresenceReceivedFromHost()
		{
			HostHasReborn = true;
		}
	}
	public static class HostAlerts
	{
		public static void Send<THandler>(string title, string message) where THandler : ModuleMessageHandler
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if (NetworkInfo.IsHost)
				{
					ShowLocal(title, message);
					return;
				}
				NetWriter val = NetWriter.Create();
				try
				{
					val.Write(title);
					val.Write(message);
					NetMessage val2 = NetMessage.ModuleCreate(typeof(THandler), val, CommonMessageRoutes.ReliableToServer, (byte?)PlayerIDManager.LocalSmallID);
					try
					{
						MessageSender.SendToServer((NetworkChannel)0, val2);
					}
					finally
					{
						((IDisposable)val2)?.Dispose();
					}
				}
				finally
				{
					((IDisposable)val)?.Dispose();
				}
			}
			catch (Exception)
			{
			}
		}

		public static void ShowLocal(string title, string message)
		{
			//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_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: 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_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_003b: Expected O, but got Unknown
			Notifier.Send(new Notification
			{
				Title = NotificationText.op_Implicit(title),
				Message = NotificationText.op_Implicit(message),
				ShowTitleOnPopup = true,
				Type = (NotificationType)1,
				PopupLength = 6f
			});
		}
	}
	public static class ObjectSpawnGuard
	{
		public static void Initialize()
		{
		}

		public static bool IsBlocked(string barcode)
		{
			if (RebornConfig.ObjectSpawnGuardEnabled.Value && !string.IsNullOrEmpty(barcode))
			{
				return RebornConfig.BlockedSpawnables.Contains(barcode);
			}
			return false;
		}
	}
	[HarmonyPatch(typeof(LocalAssetSpawner), "CreateSpawnable", new Type[] { typeof(string) })]
	public static class SpawnBlockPatch
	{
		[HarmonyPrefix]
		public static bool Prefix(string barcode)
		{
			if (!HostSync.HostEnforcementActive)
			{
				return true;
			}
			if (!ObjectSpawnGuard.IsBlocked(barcode))
			{
				return true;
			}
			return false;
		}
	}
	public static class NetworkSpawnPermissionGuard
	{
		public static void TryPatch(Harmony harmony)
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Expected O, but got Unknown
			try
			{
				MethodInfo methodInfo = AccessTools.Method(typeof(SpawnRequestMessage), "OnHandleMessage", (Type[])null, (Type[])null);
				if (!(methodInfo == null))
				{
					harmony.Patch((MethodBase)methodInfo, new HarmonyMethod(typeof(NetworkSpawnPermissionGuard), "Prefix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				}
			}
			catch (Exception)
			{
			}
		}

		public static bool Prefix(ReceivedMessage received)
		{
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			if (!NetworkInfo.IsHost)
			{
				return true;
			}
			if (!RebornConfig.RestrictNetworkedSpawningToOperators.Value)
			{
				return true;
			}
			if (((ReceivedMessage)(ref received)).Sender == 0)
			{
				return true;
			}
			try
			{
				if (!FusionDevTools.DevToolsDisabled)
				{
					return true;
				}
			}
			catch (Exception)
			{
			}
			if (((ReceivedMessage)(ref received)).Sender.HasValue && IsSenderAuthorized(((ReceivedMessage)(ref received)).Sender.Value))
			{
				return true;
			}
			if (IsAmmoOrBulletRequest(received))
			{
				return true;
			}
			return false;
		}

		private static bool IsAmmoOrBulletRequest(ReceivedMessage received)
		{
			try
			{
				string barcode = ((ReceivedMessage)(ref received)).ReadData<SerializedSpawnData>().Barcode;
				if (string.IsNullOrEmpty(barcode))
				{
					return false;
				}
				string[] array = barcode.Split(new char[6] { '.', '_', '-', ' ', '/', '\\' }, StringSplitOptions.RemoveEmptyEntries);
				foreach (string a in array)
				{
					foreach (string ammoBarcodeKeyword in RebornConfig.AmmoBarcodeKeywords)
					{
						if (string.Equals(a, ammoBarcodeKeyword, StringComparison.OrdinalIgnoreCase))
						{
							return true;
						}
						if (ModioGuard.NameSimilarity(a, ammoBarcodeKeyword) >= RebornConfig.FuzzyNameSimilarityThreshold)
						{
							return true;
						}
					}
				}
			}
			catch (Exception)
			{
			}
			return false;
		}

		private static bool IsSenderAuthorized(byte senderSmallId)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			if (!PlayerIDManager.HasPlayerID(senderSmallId))
			{
				return false;
			}
			PlayerID playerID = PlayerIDManager.GetPlayerID(senderSmallId);
			try
			{
				PermissionLevel val = default(PermissionLevel);
				Color val2 = default(Color);
				FusionPermissions.FetchPermissionLevel(playerID.PlatformID, ref val, ref val2);
				if (FusionPermissions.HasSufficientPermissions(val, (PermissionLevel)1))
				{
					return true;
				}
			}
			catch (Exception)
			{
			}
			try
			{
				if (MasterPermissionsManager.IsMaster(playerID.PlatformID))
				{
					return true;
				}
			}
			catch (Exception)
			{
			}
			return false;
		}
	}
	public static class NetworkSpawnBarcodeGuard
	{
		public static void TryPatch(Harmony harmony)
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Expected O, but got Unknown
			try
			{
				MethodInfo methodInfo = AccessTools.Method(typeof(SpawnRequestMessage), "OnHandleMessage", (Type[])null, (Type[])null);
				if (!(methodInfo == null))
				{
					harmony.Patch((MethodBase)methodInfo, new HarmonyMethod(typeof(NetworkSpawnBarcodeGuard), "Prefix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				}
			}
			catch (Exception)
			{
			}
		}

		public static bool Prefix(ReceivedMessage received)
		{
			if (!NetworkInfo.IsHost)
			{
				return true;
			}
			string barcode;
			try
			{
				barcode = ((ReceivedMessage)(ref received)).ReadData<SerializedSpawnData>().Barcode;
			}
			catch (Exception)
			{
				return true;
			}
			if (!ObjectSpawnGuard.IsBlocked(barcode))
			{
				return true;
			}
			return false;
		}
	}
	public static class PlayerGuardTick
	{
		private const float IntervalSeconds = 0.15f;

		private static float _accumulator;

		public static void Tick()
		{
			_accumulator += Time.unscaledDeltaTime;
			if (_accumulator < 0.15f)
			{
				return;
			}
			_accumulator = 0f;
			if (!HostSync.HostEnforcementActive)
			{
				return;
			}
			bool value = RebornConfig.FlyhackGuardEnabled.Value;
			bool value2 = RebornConfig.VitalityGuardEnabled.Value;
			if (!value && !value2)
			{
				return;
			}
			RigRefs val = default(RigRefs);
			foreach (PlayerID playerID in PlayerIDManager.PlayerIDs)
			{
				if (!playerID.IsMe && PlayerRepUtilities.TryGetReferences(playerID.SmallID, ref val) && val.IsValid)
				{
					if (value)
					{
						FlyhackGuard.Check(playerID, val);
					}
					if (value2)
					{
						VitalityGuard.Check(playerID, val);
					}
				}
			}
		}
	}
	public static class FlyhackGuard
	{
		private class TrackedPlayer
		{
			public Vector3 LastPosition;

			public float LastCheckTime;

			public int ViolationStrikes;
		}

		private static readonly Dictionary<byte, TrackedPlayer> _tracked = new Dictionary<byte, TrackedPlayer>();

		private const float TeleportIgnoreThreshold = 15f;

		private const int StrikesBeforeAction = 6;

		public static void Initialize()
		{
		}

		public static void Check(PlayerID playerId, RigRefs refs)
		{
			//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_004d: 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_0074: 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_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			RigManager rigManager = refs.RigManager;
			if ((Object)(object)rigManager == (Object)null)
			{
				return;
			}
			Vector3 position = ((Rig)rigManager.physicsRig).m_pelvis.position;
			float time = Time.time;
			if (!_tracked.TryGetValue(playerId.SmallID, out var value))
			{
				_tracked[playerId.SmallID] = new TrackedPlayer
				{
					LastPosition = position,
					LastCheckTime = time
				};
				return;
			}
			float num = time - value.LastCheckTime;
			if (num <= 0f)
			{
				return;
			}
			float num2 = Vector3.Distance(position, value.LastPosition);
			float num3 = num2 / num;
			if (num2 < 15f && num3 > RebornConfig.MaxAllowedSpeed.Value)
			{
				value.ViolationStrikes++;
				if (value.ViolationStrikes >= 6)
				{
					HandleFlyhackDetected(playerId, num3);
					value.ViolationStrikes = 0;
				}
			}
			else
			{
				value.ViolationStrikes = 0;
			}
			value.LastPosition = position;
			value.LastCheckTime = time;
		}

		private static void HandleFlyhackDetected(PlayerID playerId, float speed)
		{
			string value = $"exceeded max speed ({speed:F1} u/s)";
			HostAlerts.Send<FlyhackAlertMessageHandler>("Fusion: Reborn", $"Possible flyhack: Player {playerId.SmallID} ({value})");
		}

		public static void OnFlyhackAlertReceived(string title, string message)
		{
			HostAlerts.ShowLocal(title, message);
		}
	}
	public static class VitalityGuard
	{
		private class HealthTrack
		{
			public float LastKnownHealth;

			public int UnchangedAfterDamageCount;

			public bool AlreadyFlaggedHardCap;

			public bool AlreadyKicked;
		}

		private static readonly Dictionary<byte, HealthTrack> _tracked = new Dictionary<byte, HealthTrack>();

		private const int StrikesBeforeAction = 3;

		public static void Initialize()
		{
		}

		public static void Check(PlayerID playerId, RigRefs refs)
		{
			float vitalityValue = GetVitalityValue(refs);
			CheckHardCap(playerId, vitalityValue);
		}

		private static float GetVitalityValue(RigRefs refs)
		{
			_ = refs.Health;
			return 0f;
		}

		private static void CheckHardCap(PlayerID playerId, float health)
		{
			if (!_tracked.TryGetValue(playerId.SmallID, out var value))
			{
				value = new HealthTrack
				{
					LastKnownHealth = health
				};
				_tracked[playerId.SmallID] = value;
			}
			int num;
			int num2;
			if (!float.IsInfinity(health))
			{
				num = (float.IsNaN(health) ? 1 : 0);
				if (num == 0)
				{
					num2 = ((health >= 1000f) ? 1 : 0);
					goto IL_0054;
				}
			}
			else
			{
				num = 1;
			}
			num2 = 0;
			goto IL_0054;
			IL_0054:
			bool flag = (byte)num2 != 0;
			if (num != 0)
			{
				if (!value.AlreadyFlaggedHardCap)
				{
					value.AlreadyFlaggedHardCap = true;
					HandleInfiniteOrNaNDetected(playerId);
				}
			}
			else if (flag)
			{
				if (!value.AlreadyFlaggedHardCap)
				{
					value.AlreadyFlaggedHardCap = true;
					HandleOverCapDetected(playerId, health);
				}
			}
			else
			{
				value.AlreadyFlaggedHardCap = false;
				value.AlreadyKicked = false;
			}
			value.LastKnownHealth = health;
		}

		public static void DamageEventReceived(PlayerID playerId, float damageAmount, float healthBefore, float healthAfter)
		{
			if (!RebornConfig.VitalityGuardEnabled.Value || !HostSync.HostEnforcementActive)
			{
				return;
			}
			if (!_tracked.TryGetValue(playerId.SmallID, out var value))
			{
				value = new HealthTrack
				{
					LastKnownHealth = healthBefore
				};
				_tracked[playerId.SmallID] = value;
			}
			bool num = damageAmount > 0.5f;
			bool flag = healthAfter < healthBefore - 0.01f;
			if (num && !flag)
			{
				value.UnchangedAfterDamageCount++;
				if (value.UnchangedAfterDamageCount >= 3)
				{
					HandleOverCapDetected(playerId, healthAfter, "no-sold repeated damage without health decreasing");
					value.UnchangedAfterDamageCount = 0;
				}
			}
			else
			{
				value.UnchangedAfterDamageCount = 0;
			}
			value.LastKnownHealth = healthAfter;
		}

		private static void HandleInfiniteOrNaNDetected(PlayerID playerId)
		{
			string playerName = GetPlayerName(playerId);
			string text = "vitality value is Infinity/NaN";
			HostAlerts.Send<VitalityAlertMessageHandler>("Fusion: Reborn", $"Infinite vitality detected: {playerName} ({text})" + (RebornConfig.KickOnInfiniteVitality.Value ? " - kicking." : ""));
			if (RebornConfig.KickOnInfiniteVitality.Value)
			{
				TryKick(playerId, text);
			}
		}

		private static void HandleOverCapDetected(PlayerID playerId, float health, string reasonOverride = null)
		{
			string playerName = GetPlayerName(playerId);
			string value = reasonOverride ?? $"vitality value {health:F0} is at/above the {1000f:F0} hard cap";
			HostAlerts.Send<VitalityAlertMessageHandler>("Fusion: Reborn", $"Possible infinite vitality: {playerName} ({value})");
		}

		private static void TryKick(PlayerID playerId, string reason)
		{
			if (!NetworkInfo.IsHost)
			{
				return;
			}
			try
			{
				NetworkHelper.KickUser(playerId);
			}
			catch (Exception)
			{
			}
		}

		private static string GetPlayerName(PlayerID playerId)
		{
			return $"Player {playerId.SmallID}";
		}

		public static void OnVitalityAlertReceived(string title, string message)
		{
			HostAlerts.ShowLocal(title, message);
		}
	}
	public static class PanicKick
	{
		public static void Initialize()
		{
		}

		public static void Tick()
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			if (NetworkInfo.IsHost && NetworkInfo.HasServer && RebornConfig.PanicKickEnabled.Value && Input.GetKeyDown(RebornConfig.PanicKickKey.Value))
			{
				KickAllPlayers();
			}
		}

		public static void KickAllPlayers()
		{
			List<PlayerID> list = new List<PlayerID>(PlayerIDManager.PlayerIDs);
			int num = 0;
			foreach (PlayerID item in list)
			{
				if (!item.IsMe)
				{
					try
					{
						NetworkHelper.KickUser(item);
						num++;
					}
					catch (Exception)
					{
					}
				}
			}
			HostAlerts.ShowLocal("Fusion: Reborn", $"Panic kick triggered - kicked {num} player(s).");
		}
	}
	public static class DespawnAllLoop
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static ServerEvent <0>__Stop;
		}

		private const float IntervalSeconds = 0.2f;

		private static float _accumulator;

		private static bool _active;

		public static void Initialize()
		{
			//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)
			//IL_001b: Expected O, but got Unknown
			object obj = <>O.<0>__Stop;
			if (obj == null)
			{
				ServerEvent val = Stop;
				<>O.<0>__Stop = val;
				obj = (object)val;
			}
			MultiplayerHooking.OnDisconnected += (ServerEvent)obj;
		}

		public static void Tick()
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			if (!NetworkInfo.IsHost || !NetworkInfo.HasServer)
			{
				_active = false;
			}
			else
			{
				if (!RebornConfig.DespawnAllKeyEnabled.Value)
				{
					return;
				}
				if (Input.GetKeyDown(RebornConfig.DespawnAllKey.Value))
				{
					_active = !_active;
				}
				if (_active)
				{
					_accumulator += Time.unscaledDeltaTime;
					if (!(_accumulator < 0.2f))
					{
						_accumulator = 0f;
						PooleeUtilities.DespawnAll();
					}
				}
			}
		}

		public static void DespawnAllNow()
		{
			PooleeUtilities.DespawnAll();
		}

		private static void Stop()
		{
			_active = false;
		}
	}
	public static class AutoVolumeLimiter
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static ServerEvent <0>__ResetOnDisconnect;
		}

		private static readonly float[] _samples = new float[256];

		private static bool _baselineCaptured;

		private static float _baselineVolume = 1f;

		private static float _currentReduction;

		private static bool _tooLoud;

		private const float StepDownPerSecond = 1.5f;

		private const float StepUpPerSecond = 0.5f;

		private const float SilenceFloorDb = -80f;

		private const float SampleIntervalSeconds = 0.1f;

		private static float _sampleAccumulator;

		public static void Initialize()
		{
			//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)
			//IL_001b: Expected O, but got Unknown
			object obj = <>O.<0>__ResetOnDisconnect;
			if (obj == null)
			{
				ServerEvent val = ResetOnDisconnect;
				<>O.<0>__ResetOnDisconnect = val;
				obj = (object)val;
			}
			MultiplayerHooking.OnDisconnected += (ServerEvent)obj;
		}

		public static void Tick()
		{
			if (!NetworkInfo.HasServer)
			{
				if (_baselineCaptured)
				{
					ResetOnDisconnect();
				}
				return;
			}
			if (!RebornConfig.AutoVolumeLimiterEnabled.Value)
			{
				if (_baselineCaptured)
				{
					ResetOnDisconnect();
				}
				return;
			}
			if (!_baselineCaptured)
			{
				_baselineVolume = AudioListener.volume;
				_baselineCaptured = true;
			}
			float unscaledDeltaTime = Time.unscaledDeltaTime;
			_sampleAccumulator += unscaledDeltaTime;
			if (_sampleAccumulator >= 0.1f)
			{
				_sampleAccumulator = 0f;
				_tooLoud = MeasureLoudnessDb() > RebornConfig.AutoVolumeLoudnessThreshold.Value;
			}
			float num = Mathf.Clamp01(RebornConfig.AutoVolumeMaxReduction.Value);
			if (_tooLoud)
			{
				_currentReduction = Mathf.Min(_currentReduction + 1.5f * unscaledDeltaTime, num);
			}
			else
			{
				_currentReduction = Mathf.Max(_currentReduction - 0.5f * unscaledDeltaTime, 0f);
			}
			AudioListener.volume = Mathf.Clamp01(_baselineVolume - _currentReduction);
		}

		private static float MeasureLoudnessDb()
		{
			AudioListener.GetOutputData(Il2CppStructArray<float>.op_Implicit(_samples), 0);
			float num = 0f;
			float[] samples = _samples;
			foreach (float num2 in samples)
			{
				num += num2 * num2;
			}
			float num3 = Mathf.Sqrt(num / (float)_samples.Length);
			if (!(num3 > 0.0001f))
			{
				return -80f;
			}
			return 20f * Mathf.Log10(num3);
		}

		private static void ResetOnDisconnect()
		{
			if (_baselineCaptured)
			{
				AudioListener.volume = _baselineVolume;
			}
			_baselineCaptured = false;
			_currentReduction = 0f;
			_sampleAccumulator = 0f;
			_tooLoud = false;
		}
	}
	public static class EmissionBloomGuard
	{
		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static UpdateEvent <>9__2_0;

			internal void <Initialize>b__2_0()
			{
				_processedInstanceIds.Clear();
			}
		}

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

		private static readonly int _emissionColorId = Shader.PropertyToID("_EmissionColor");

		public static void Initialize()
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			object obj = <>c.<>9__2_0;
			if (obj == null)
			{
				UpdateEvent val = delegate
				{
					_processedInstanceIds.Clear();
				};
				<>c.<>9__2_0 = val;
				obj = (object)val;
			}
			MultiplayerHooking.OnTargetLevelLoaded += (UpdateEvent)obj;
		}

		public static void OnPooleeSpawned(Poolee poolee)
		{
			if (!RebornConfig.EmissionBloomGuardEnabled.Value || (Object)(object)poolee == (Object)null)
			{
				return;
			}
			GameObject gameObject = ((Component)poolee).gameObject;
			if ((Object)(object)gameObject == (Object)null)
			{
				return;
			}
			int instanceID = ((Object)gameObject).GetInstanceID();
			if (!_processedInstanceIds.Add(instanceID))
			{
				return;
			}
			try
			{
				StripOverbrightEmission(gameObject);
			}
			catch (Exception)
			{
			}
		}

		private static void StripOverbrightEmission(GameObject root)
		{
			//IL_0094: 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_00a3: 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_00b7: 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_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Expected O, but got Unknown
			Il2CppArrayBase<Renderer> componentsInChildren = root.GetComponentsInChildren<Renderer>(true);
			if (componentsInChildren == null || componentsInChildren.Length == 0)
			{
				return;
			}
			float value = RebornConfig.EmissionIntensityThreshold.Value;
			MaterialPropertyBlock val = null;
			foreach (Renderer item in componentsInChildren)
			{
				if ((Object)(object)item == (Object)null)
				{
					continue;
				}
				Il2CppReferenceArray<Material> sharedMaterials = item.sharedMaterials;
				if (sharedMaterials == null || ((Il2CppArrayBase<Material>)(object)sharedMaterials).Length == 0)
				{
					continue;
				}
				bool flag = false;
				foreach (Material item2 in (Il2CppArrayBase<Material>)(object)sharedMaterials)
				{
					if (!((Object)(object)item2 == (Object)null) && item2.HasProperty(_emissionColorId))
					{
						Color color = item2.GetColor(_emissionColorId);
						if (Mathf.Max(new float[3] { color.r, color.g, color.b }) >= value)
						{
							flag = true;
							break;
						}
					}
				}
				if (flag)
				{
					if (val == null)
					{
						val = new MaterialPropertyBlock();
					}
					item.GetPropertyBlock(val);
					val.SetColor(_emissionColorId, Color.black);
					item.SetPropertyBlock(val);
					val.Clear();
				}
			}
		}
	}
	[HarmonyPatch(typeof(LocalAssetSpawner), "Spawn")]
	public static class SceneObjectCapGuard
	{
		public static void Initialize()
		{
		}

		public static void OnPooleeSpawned(Poolee poolee)
		{
			//IL_003b: 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)
			if (!NetworkInfo.IsHost || !NetworkInfo.HasServer || (Object)(object)poolee == (Object)null)
			{
				return;
			}
			int value = RebornConfig.MaxSceneObjects.Value;
			if (CountSpawnedProps() <= value)
			{
				return;
			}
			NetworkEntity val = FindEntityForPoolee(poolee);
			if (val == null)
			{
				return;
			}
			try
			{
				NetworkAssetSpawner.Despawn(new DespawnRequestInfo
				{
					EntityID = val.ID,
					DespawnEffect = false
				});
			}
			catch (Exception)
			{
			}
		}

		private static int CountSpawnedProps()
		{
			int num = 0;
			foreach (NetworkEntity value in NetworkEntityManager.IDManager.RegisteredEntities.IDEntityLookup.Values)
			{
				if (value.GetExtender<NetworkProp>() != null)
				{
					num++;
				}
			}
			return num;
		}

		private static NetworkEntity FindEntityForPoolee(Poolee poolee)
		{
			foreach (NetworkEntity value in NetworkEntityManager.IDManager.RegisteredEntities.IDEntityLookup.Values)
			{
				NetworkProp extender = value.GetExtender<NetworkProp>();
				if ((Object)(object)((extender != null) ? extender.MarrowEntity : null) != (Object)null && (Object)(object)((Component)extender.MarrowEntity).gameObject == (Object)(object)((Component)poolee).gameObject)
				{
					return value;
				}
			}
			return null;
		}
	}
	public static class EmissionSpawnHookPatch
	{
		[HarmonyPrefix]
		public static void Prefix(ref Action<Poolee> spawnCallback)
		{
			Action<Poolee> original = spawnCallback;
			spawnCallback = delegate(Poolee poolee)
			{
				original?.Invoke(poolee);
				EmissionBloomGuard.OnPooleeSpawned(poolee);
				SceneObjectCapGuard.OnPooleeSpawned(poolee);
			};
		}
	}
	public static class ModioGuard
	{
		public static void Initialize()
		{
		}

		public static bool IsBlocked(string modIdOrNameId, out string matchedReason)
		{
			matchedReason = null;
			if (!RebornConfig.ModBlacklistEnabled.Value)
			{
				return false;
			}
			if (string.IsNullOrWhiteSpace(modIdOrNameId))
			{
				return false;
			}
			foreach (string blockedModioProfile in RebornConfig.BlockedModioProfiles)
			{
				if (string.Equals(blockedModioProfile, modIdOrNameId, StringComparison.OrdinalIgnoreCase))
				{
					matchedReason = "exact match to blacklisted entry '" + blockedModioProfile + "'";
					return true;
				}
			}
			foreach (string blockedModioProfile2 in RebornConfig.BlockedModioProfiles)
			{
				if (!IsNumeric(blockedModioProfile2))
				{
					float num = NameSimilarity(blockedModioProfile2, modIdOrNameId);
					if (num >= RebornConfig.FuzzyNameSimilarityThreshold)
					{
						matchedReason = $"name similar ({num:P0}) to blacklisted entry '{blockedModioProfile2}'";
						return true;
					}
				}
			}
			return false;
		}

		private static bool IsNumeric(string s)
		{
			for (int i = 0; i < s.Length; i++)
			{
				if (!char.IsDigit(s[i]))
				{
					return false;
				}
			}
			return s.Length > 0;
		}

		public static float NameSimilarity(string a, string b)
		{
			a = Normalize(a);
			b = Normalize(b);
			if (a.Length == 0 && b.Length == 0)
			{
				return 1f;
			}
			int num = LevenshteinDistance(a, b);
			int num2 = Math.Max(a.Length, b.Length);
			if (num2 != 0)
			{
				return 1f - (float)num / (float)num2;
			}
			return 1f;
		}

		private static string Normalize(string s)
		{
			return s.ToLowerInvariant().Replace("_", "").Replace("-", "")
				.Replace(".", "")
				.Replace(" ", "");
		}

		private static int LevenshteinDistance(string a, string b)
		{
			int[,] array = new int[a.Length + 1, b.Length + 1];
			for (int i = 0; i <= a.Length; i++)
			{
				array[i, 0] = i;
			}
			for (int j = 0; j <= b.Length; j++)
			{
				array[0, j] = j;
			}
			for (int k = 1; k <= a.Length; k++)
			{
				for (int l = 1; l <= b.Length; l++)
				{
					int num = ((a[k - 1] != b[l - 1]) ? 1 : 0);
					array[k, l] = Math.Min(Math.Min(array[k - 1, l] + 1, array[k, l - 1] + 1), array[k - 1, l - 1] + num);
				}
			}
			return array[a.Length, b.Length];
		}
	}
	[HarmonyPatch(typeof(ModIODownloader), "EnqueueDownload")]
	public static class ModioDownloadBlockPatch
	{
		[HarmonyPrefix]
		public static bool Prefix(ModTransaction transaction)
		{
			//IL_000f: 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)
			ModIOFile? val = ((transaction != null) ? new ModIOFile?(transaction.ModFile) : ((ModIOFile?)null));
			if (ModioGuard.IsBlocked(val.HasValue ? ((object)val.GetValueOrDefault()/*cast due to .constrained prefix*/).ToString() : null, out var _))
			{
				return false;
			}
			return true;
		}
	}
	public static class ServerHider
	{
		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static GenericLobbyDelegate <>9__1_0;

			internal bool <Initialize>b__1_0(INetworkLobby lobby, LobbyMetadataInfo info)
			{
				if (!RebornConfig.ServerHidingEnabled.Value)
				{
					return true;
				}
				LobbyInfo lobbyInfo = ((LobbyMetadataInfo)(ref info)).LobbyInfo;
				return !ShouldHide((lobbyInfo != null) ? lobbyInfo.LobbyName : null);
			}
		}

		private static GenericLobbyFilter _filter;

		public static void Initialize()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Expected O, but got Unknown
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Expected O, but got Unknown
			object obj = <>c.<>9__1_0;
			if (obj == null)
			{
				GenericLobbyDelegate val = delegate(INetworkLobby lobby, LobbyMetadataInfo info)
				{
					if (!RebornConfig.ServerHidingEnabled.Value)
					{
						return true;
					}
					LobbyInfo lobbyInfo = ((LobbyMetadataInfo)(ref info)).LobbyInfo;
					return !ShouldHide((lobbyInfo != null) ? lobbyInfo.LobbyName : null);
				};
				<>c.<>9__1_0 = val;
				obj = (object)val;
			}
			_filter = new GenericLobbyFilter("Fusion: Reborn Codeword Filter", (GenericLobbyDelegate)obj);
			LobbyFilterManager.AddLobbyFilter((ILobbyFilter)(object)_filter);
		}

		public static bool ShouldHide(string serverName)
		{
			if (string.IsNullOrEmpty(serverName))
			{
				return false;
			}
			foreach (string serverHideCodeword in RebornConfig.ServerHideCodewords)
			{
				if (serverName.IndexOf(serverHideCodeword, StringComparison.OrdinalIgnoreCase) >= 0)
				{
					return true;
				}
			}
			return false;
		}
	}
	public static class RebornMenu
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static ServerEvent <0>__ShowHostPage;

			public static ServerEvent <1>__EnforceHostPageVisibility;

			public static ServerEvent <2>__HideHostPage;

			public static Action <3>__KickAllPlayers;

			public static Action <4>__DespawnAllNow;

			public static Action <5>__TeleportAllToHost;
		}

		private const int MaxElementsPerPage = 20;

		private const bool DebugPreviewHostPage = false;

		private static Page _mainPage;

		private static Page _hostPage;

		private static readonly FieldInfo _pageElementsField = typeof(Page).GetField("_elements", BindingFlags.Instance | BindingFlags.NonPublic);

		public static void Setup()
		{
			//IL_000a: 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_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Expected O, but got Unknown
			//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_0057: Expected O, but got Unknown
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Expected O, but got Unknown
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: 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_0153: 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)
			_mainPage = Page.Root.CreatePage("Fusion: Reborn", Color.red, 20, true);
			object obj = <>O.<0>__ShowHostPage;
			if (obj == null)
			{
				ServerEvent val = ShowHostPage;
				<>O.<0>__ShowHostPage = val;
				obj = (object)val;
			}
			MultiplayerHooking.OnStartedServer += (ServerEvent)obj;
			object obj2 = <>O.<1>__EnforceHostPageVisibility;
			if (obj2 == null)
			{
				ServerEvent val2 = EnforceHostPageVisibility;
				<>O.<1>__EnforceHostPageVisibility = val2;
				obj2 = (object)val2;
			}
			MultiplayerHooking.OnJoinedServer += (ServerEvent)obj2;
			object obj3 = <>O.<2>__HideHostPage;
			if (obj3 == null)
			{
				ServerEvent val3 = HideHostPage;
				<>O.<2>__HideHostPage = val3;
				obj3 = (object)val3;
			}
			MultiplayerHooking.OnDisconnected += (ServerEvent)obj3;
			if (NetworkInfo.HasServer && NetworkInfo.IsHost)
			{
				ShowHostPage();
			}
			_mainPage.CreateBool("Hide Hood Avatars", Color.white, RebornConfig.ModBlacklistEnabled.Value, (Action<bool>)delegate(bool v)
			{
				RebornConfig.ModBlacklistEnabled.Value = v;
				RebornConfig.Save();
			});
			_mainPage.CreateBool("Hide Offensive Hood & Racist Servers", Color.white, RebornConfig.ServerHidingEnabled.Value, (Action<bool>)delegate(bool v)
			{
				RebornConfig.ServerHidingEnabled.Value = v;
				RebornConfig.Save();
			});
			_mainPage.CreateBool("Ear Protection", Color.white, RebornConfig.AutoVolumeLimiterEnabled.Value, (Action<bool>)delegate(bool v)
			{
				RebornConfig.AutoVolumeLimiterEnabled.Value = v;
				RebornConfig.Save();
			});
			_mainPage.CreateFloat("Max Volume Reduction", Color.white, RebornConfig.AutoVolumeMaxReduction.Value, 0.05f, 0f, 1f, (Action<float>)delegate(float v)
			{
				RebornConfig.AutoVolumeMaxReduction.Value = v;
				RebornConfig.Save();
			});
			_mainPage.CreateBool("Disable Overbright Emission", Color.white, RebornConfig.EmissionBloomGuardEnabled.Value, (Action<bool>)delegate(bool v)
			{
				RebornConfig.EmissionBloomGuardEnabled.Value = v;
				RebornConfig.Save();
			});
		}

		private static void ShowHostPage()
		{
			//IL_0012: 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_006c: 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_00e8: 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_0164: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e9: 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_022c: Unknown result type (might be due to invalid IL or missing references)
			//IL_025c: Unknown result type (might be due to invalid IL or missing references)
			//IL_029a: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_030d: Unknown result type (might be due to invalid IL or missing references)
			if (_hostPage == null)
			{
				_hostPage = _mainPage.CreatePage("Host Controls (Owner Only)", Color.yellow, 20, true);
				_hostPage.CreateBool("Block Greifing Items", Color.white, RebornConfig.ObjectSpawnGuardEnabled.Value, (Action<bool>)delegate(bool v)
				{
					RebornConfig.ObjectSpawnGuardEnabled.Value = v;
					RebornConfig.Save();
				});
				_hostPage.CreateBool("Flyhack Detection", Color.white, RebornConfig.FlyhackGuardEnabled.Value, (Action<bool>)delegate(bool v)
				{
					RebornConfig.FlyhackGuardEnabled.Value = v;
					RebornConfig.Save();
				});
				_hostPage.CreateBool("Infinite Health Detection", Color.white, RebornConfig.VitalityGuardEnabled.Value, (Action<bool>)delegate(bool v)
				{
					RebornConfig.VitalityGuardEnabled.Value = v;
					RebornConfig.Save();
				});
				_hostPage.CreateBool("Kick on Infinite Health", Color.white, RebornConfig.KickOnInfiniteVitality.Value, (Action<bool>)delegate(bool v)
				{
					RebornConfig.KickOnInfiniteVitality.Value = v;
					RebornConfig.Save();
				});
				_hostPage.CreateBool("Block Spawn Requests", Color.white, RebornConfig.RestrictNetworkedSpawningToOperators.Value, (Action<bool>)delegate(bool v)
				{
					RebornConfig.RestrictNetworkedSpawningToOperators.Value = v;
					RebornConfig.Save();
				});
				_hostPage.CreateInt("Max Scene Objects", Color.white, RebornConfig.MaxSceneObjects.Value, 100, 100, 3000, (Action<int>)delegate(int v)
				{
					RebornConfig.MaxSceneObjects.Value = v;
					RebornConfig.Save();
				});
				_hostPage.CreateBool("Kick All Key Enabled", Color.white, RebornConfig.PanicKickEnabled.Value, (Action<bool>)delegate(bool v)
				{
					RebornConfig.PanicKickEnabled.Value = v;
					RebornConfig.Save();
				});
				_hostPage.CreateEnum("Kick All Key", Color.white, (Enum)(object)RebornConfig.PanicKickKey.Value, (Action<Enum>)delegate(Enum v)
				{
					//IL_0006: Unknown result type (might be due to invalid IL or missing references)
					RebornConfig.PanicKickKey.Value = (KeyCode)(object)v;
					RebornConfig.Save();
				});
				_hostPage.CreateFunction("Kick All Players Now", Color.red, (Action)PanicKick.KickAllPlayers);
				_hostPage.CreateBool("Despawn All Key Enabled", Color.white, RebornConfig.DespawnAllKeyEnabled.Value, (Action<bool>)delegate(bool v)
				{
					RebornConfig.DespawnAllKeyEnabled.Value = v;
					RebornConfig.Save();
				});
				_hostPage.CreateEnum("Despawn All Key", Color.white, (Enum)(object)RebornConfig.DespawnAllKey.Value, (Action<Enum>)delegate(Enum v)
				{
					//IL_0006: Unknown result type (might be due to invalid IL or missing references)
					RebornConfig.DespawnAllKey.Value = (KeyCode)(object)v;
					RebornConfig.Save();
				});
				_hostPage.CreateFunction("Despawn All Now", Color.red, (Action)DespawnAllLoop.DespawnAllNow);
				_hostPage.CreateFunction("Teleport All", Color.red, (Action)TeleportAllToHost);
				TryReorderHostLinkUnderBugReport();
			}
		}

		private static void TeleportAllToHost()
		{
			foreach (PlayerID playerID in PlayerIDManager.PlayerIDs)
			{
				if (!playerID.IsMe)
				{
					PermissionSender.SendPermissionRequest((PermissionCommandType)4, (byte?)playerID.SmallID);
				}
			}
		}

		private static void TryReorderHostLinkUnderBugReport()
		{
			try
			{
				if (_hostPage == null)
				{
					return;
				}
				PageLinkElement val = null;
				foreach (Element element in _mainPage.Elements)
				{
					PageLinkElement val2 = (PageLinkElement)(object)((element is PageLinkElement) ? element : null);
					if (val2 != null && val2.LinkedPage == _hostPage)
					{
						val = val2;
						break;
					}
				}
				if (val != null && _pageElementsField?.GetValue(_mainPage) is List<Element> list)
				{
					list.Remove((Element)(object)val);
					list.Insert(1, (Element)(object)val);
				}
			}
			catch (Exception)
			{
			}
		}

		private static void HideHostPage()
		{
			if (_hostPage != null)
			{
				_mainPage.RemovePage(_hostPage);
				_hostPage = null;
			}
		}

		private static void EnforceHostPageVisibility()
		{
			if (!NetworkInfo.IsHost)
			{
				HideHostPage();
			}
		}
	}
}