using System;
using System.Collections;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using System.Threading;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Core.Logging.Interpolation;
using BepInEx.IL2CPP;
using BepInEx.IL2CPP.Utils;
using BepInEx.Logging;
using CrabDevKit.Intermediary;
using HarmonyLib;
using Il2CppSystem.Runtime.InteropServices;
using Microsoft.CodeAnalysis;
using PersistentData;
using SteamworksNative;
using TMPro;
using UnhollowerBaseLib;
using UnityEngine;
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: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.0.0.0")]
[module: UnverifiableCode]
[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 AntiCrasher
{
	internal static class LobbyTracker
	{
		internal static HashSet<ulong> currentMembers = new HashSet<ulong>();

		internal static HashSet<ulong> blockedMembers = new HashSet<ulong>();

		internal static void Init()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			new Harmony("AntiCrasher.LobbyTracker").PatchAll(typeof(LobbyTracker));
		}

		[HarmonyPatch(typeof(MonoBehaviourPublicObInUIgaStCSBoStcuCSUnique), "Method_Private_Void_LobbyEnter_t_PDM_1")]
		[HarmonyPrefix]
		[HarmonyPriority(int.MaxValue)]
		internal static void PreSteamManagerLobbyEnter(LobbyEnter_t param_1)
		{
			//IL_0016: 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_003d: 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)
			currentMembers.Clear();
			blockedMembers.Clear();
			CSteamID val = default(CSteamID);
			((CSteamID)(ref val))..ctor(param_1.m_ulSteamIDLobby);
			int numLobbyMembers = SteamMatchmaking.GetNumLobbyMembers(val);
			currentMembers.EnsureCapacity(numLobbyMembers);
			for (int i = 0; i < numLobbyMembers; i++)
			{
				currentMembers.Add(SteamMatchmaking.GetLobbyMemberByIndex(val, i).m_SteamID);
			}
		}

		[HarmonyPatch(typeof(MonoBehaviourPublicObInUIgaStCSBoStcuCSUnique), "Method_Private_Void_LobbyChatUpdate_t_PDM_3")]
		[HarmonyPrefix]
		[HarmonyPriority(int.MaxValue)]
		internal static void PreSteamManagerPlayerJoinOrLeave(LobbyChatUpdate_t param_1)
		{
			//IL_0000: 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_0031: 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)
			if (param_1.m_rgfChatMemberStateChange == 1)
			{
				currentMembers.Add(param_1.m_ulSteamIDUserChanged);
				return;
			}
			currentMembers.Remove(param_1.m_ulSteamIDUserChanged);
			blockedMembers.Remove(param_1.m_ulSteamIDUserChanged);
		}

		[HarmonyPatch(typeof(SteamMatchmaking), "LeaveLobby")]
		[HarmonyPrefix]
		[HarmonyPriority(int.MaxValue)]
		internal static void PreSteamMatchmakingLeaveLobby()
		{
			currentMembers.Clear();
			blockedMembers.Clear();
		}
	}
	internal static class PersistentDataCompatibility
	{
		internal static bool? enabled;

		internal static bool Enabled
		{
			get
			{
				if (enabled.HasValue)
				{
					return enabled.Value;
				}
				bool? flag = (enabled = ((BaseChainloader<BasePlugin>)(object)IL2CPPChainloader.Instance).Plugins.ContainsKey("lammas123.PersistentData"));
				return flag.Value;
			}
		}

		[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
		internal static bool SetClientData(ulong clientId, string key, string value)
		{
			//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)
			ClientDataFile clientDataFile = Api.GetClientDataFile(clientId);
			bool result = ((ClientDataFile)(ref clientDataFile)).Set(key, value);
			((ClientDataFile)(ref clientDataFile)).SaveFile();
			return result;
		}
	}
	internal static class PacketLogger
	{
		internal sealed class PacketLog
		{
			internal DateTime time;

			internal ulong senderId;

			internal string senderName;

			internal int channel;

			internal int packetThisFrame;

			internal byte[] bytes;
		}

		private static readonly ConcurrentQueue<PacketLog> packetQueue = new ConcurrentQueue<PacketLog>();

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

		private static Thread writerThread;

		private static volatile bool writerRunning;

		internal static void Init()
		{
			StartWriterThread();
		}

		private static void StartWriterThread()
		{
			if (!writerRunning)
			{
				writerRunning = true;
				writerThread = new Thread(PacketWriterLoop)
				{
					IsBackground = true,
					Name = "AntiCrasherPacketWriter"
				};
				writerThread.Start();
				((BasePlugin)AntiCrasher.Instance).Log.LogInfo((object)"Started PacketLogger writer thread");
			}
		}

		private static void PacketWriterLoop()
		{
			string path = Path.Combine(Paths.BepInExRootPath, "PacketLog.txt");
			try
			{
				using FileStream stream = new FileStream(path, FileMode.Truncate, FileAccess.Write, FileShare.Read, 8192, FileOptions.WriteThrough);
				using StreamWriter streamWriter = new StreamWriter(stream, Encoding.UTF8)
				{
					AutoFlush = false
				};
				StringBuilder stringBuilder = new StringBuilder(16384);
				while (writerRunning)
				{
					signal.WaitOne(100);
					bool flag = false;
					PacketLog result;
					while (packetQueue.TryDequeue(out result))
					{
						flag = true;
						stringBuilder.Append($"{DateTime.Now,-11:h:mm:ss tt} ").Append(result.senderName).Append(" (@")
							.Append(result.senderId)
							.Append(") ");
						stringBuilder.Append('#').Append(result.packetThisFrame).Append(' ')
							.Append((object)(EnumNPublicSealedvaTo3vToUnique)result.channel)
							.Append(" Len:")
							.Append(result.bytes.Length)
							.Append(' ');
						stringBuilder.Append(BitConverter.ToString(result.bytes));
						stringBuilder.AppendLine();
						if (stringBuilder.Length > 65536)
						{
							streamWriter.Write(stringBuilder.ToString());
							stringBuilder.Clear();
							streamWriter.Flush();
						}
					}
					if (flag && stringBuilder.Length > 0)
					{
						streamWriter.Write(stringBuilder.ToString());
						stringBuilder.Clear();
						streamWriter.Flush();
					}
				}
				if (stringBuilder.Length > 0)
				{
					streamWriter.Write(stringBuilder.ToString());
					streamWriter.Flush();
				}
			}
			catch (Exception ex)
			{
				writerRunning = false;
				try
				{
					File.AppendAllText(path, "\n[PacketWriterLoop crashed]\n" + ex?.ToString() + "\n");
				}
				catch
				{
				}
			}
		}

		internal static void EnqueuePacket(ulong senderId, int channel, int packetThisFrame, byte[] data)
		{
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			if (AntiCrasher.Instance.packetLogging && writerRunning && senderId != 0L)
			{
				packetQueue.Enqueue(new PacketLog
				{
					time = DateTime.Now,
					senderId = senderId,
					senderName = SteamFriends.GetFriendPersonaName(new CSteamID(senderId)),
					channel = channel,
					packetThisFrame = packetThisFrame,
					bytes = data
				});
				signal.Set();
			}
		}
	}
	internal static class HandlePacketPatches
	{
		internal static Coroutine keybindCoro;

		private const int MIN_PACKET_SIZE = 8;

		private static int _maxHandledPackets;

		private static int _totalHandledPackets;

		internal static IEnumerator CoroKeybinds()
		{
			while (true)
			{
				yield return null;
				if ((Input.GetKey((KeyCode)308) || Input.GetKey((KeyCode)307)) && Input.GetKeyDown((KeyCode)116))
				{
					((BasePlugin)AntiCrasher.Instance).Log.LogInfo((object)"Tested AntiCrasher");
					if (Object.op_Implicit((Object)(object)MonoBehaviourPublicRaovTMinTemeColoonCoUnique.Instance))
					{
						MonoBehaviourPublicRaovTMinTemeColoonCoUnique.Instance.AppendMessage(0uL, "Functional", "AntiCrasher");
					}
				}
			}
		}

		[HarmonyPatch(typeof(MonoBehaviourPublicObInVoAwVoVoVoVoVoVoUnique), "Awake")]
		[HarmonyPostfix]
		internal static void PostMainManagerAwake()
		{
			if (keybindCoro == null)
			{
				keybindCoro = MonoBehaviourExtensions.StartCoroutine((MonoBehaviour)(object)MonoBehaviourPublicObInVoAwVoVoVoVoVoVoUnique.Instance, CoroKeybinds());
			}
		}

		[HarmonyPatch(typeof(MonoBehaviourPublicInStInpabyDiInpaby2Unique), "Update")]
		[HarmonyPostfix]
		internal static void PostSteamPacketManagerUpdate()
		{
			while (_maxHandledPackets == SteamPacketManagerExtensions.deobf_messagesToCheckFor)
			{
				((BasePlugin)AntiCrasher.Instance).Log.LogInfo((object)"Handled 70 packets! Checking for more...");
				_maxHandledPackets = 0;
				MonoBehaviourPublicInStInpabyDiInpaby2Unique.CheckForPackets();
			}
			_totalHandledPackets = 0;
		}

		[HarmonyPatch(typeof(SteamNetworkingMessages), "ReceiveMessagesOnChannel")]
		[HarmonyPostfix]
		internal static void PostSteamPacketManagerUpdate(int __result, int nLocalChannel)
		{
			if ((nLocalChannel == 0 || nLocalChannel == 1) && __result > _maxHandledPackets)
			{
				_maxHandledPackets = __result;
			}
		}

		[HarmonyPatch(typeof(MonoBehaviourPublicInStInpabyDiInpaby2Unique), "Method_Private_Static_Void_SteamNetworkingMessage_t_Int32_0")]
		[HarmonyPrefix]
		[HarmonyPriority(int.MinValue)]
		internal static bool PreSteamPacketManagerHandlePacket(SteamNetworkingMessage_t param_0, int param_1)
		{
			//IL_0026: 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_00a3: Expected O, but got Unknown
			//IL_01b3: 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_010e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: Invalid comparison between Unknown and I4
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_0128: Invalid comparison between Unknown and I4
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_0118: Invalid comparison between Unknown and I4
			//IL_012a: Unknown result type (might be due to invalid IL or missing references)
			//IL_012e: Invalid comparison between Unknown and I4
			//IL_011a: Unknown result type (might be due to invalid IL or missing references)
			//IL_011d: Invalid comparison between Unknown and I4
			//IL_0130: Unknown result type (might be due to invalid IL or missing references)
			//IL_0134: Invalid comparison between Unknown and I4
			_totalHandledPackets++;
			ulong steamID = param_0.m_identityPeer.GetSteamID64();
			if (!SessionVerifier.IsValid(steamID))
			{
				MonoBehaviourPublicObInUIgaStCSBoStcuCSUnique.Instance.StopP2P(new CSteamID(steamID));
				if (AntiCrasher.Instance.packetLogging)
				{
					PacketLogger.EnqueuePacket(steamID, -1, _totalHandledPackets, Array.Empty<byte>());
				}
				return false;
			}
			int cbSize = param_0.m_cbSize;
			if (cbSize < 8)
			{
				AntiCrasher.Instance.Flag(steamID, AntiCrashReason.InvalidPacketLength);
				if (AntiCrasher.Instance.packetLogging)
				{
					PacketLogger.EnqueuePacket(steamID, -2, _totalHandledPackets, Array.Empty<byte>());
				}
				return false;
			}
			Il2CppStructArray<byte> val = new Il2CppStructArray<byte>((long)cbSize);
			Marshal.Copy(param_0.m_pData, val, 0, cbSize);
			ObjectPublicIDisposableLi1ByInByBoUnique val2 = new ObjectPublicIDisposableLi1ByInByBoUnique();
			PacketExtensions.SetBytes(val2, Il2CppArrayBase<byte>.op_Implicit((Il2CppArrayBase<byte>)(object)val));
			PacketExtensions.ReadInt(val2, true);
			int num = PacketExtensions.ReadInt(val2, true);
			if (AntiCrasher.Instance.packetLogging)
			{
				PacketLogger.EnqueuePacket(steamID, param_1, _totalHandledPackets, Il2CppArrayBase<byte>.op_Implicit((Il2CppArrayBase<byte>)(object)val));
			}
			if (param_1 == 1)
			{
				if (!Enum.IsDefined(typeof(EnumPublicSealedvahawesepirepiselostUnique), num))
				{
					AntiCrasher.Instance.Flag(steamID, AntiCrashReason.InvalidClientPacketType);
					return false;
				}
				EnumPublicSealedvahawesepirepiselostUnique val3 = (EnumPublicSealedvahawesepirepiselostUnique)num;
				if ((int)val3 <= 7)
				{
					if ((int)val3 == 3)
					{
						AntiCrasher.Instance.Flag(steamID, AntiCrashReason.UnusedPingPongPacket);
						return false;
					}
					if ((int)val3 == 7)
					{
						AntiCrasher.Instance.Flag(steamID, AntiCrashReason.UnusedColorChangeRequestPacket);
						return false;
					}
				}
				else
				{
					if ((int)val3 == 12)
					{
						AntiCrasher.Instance.Flag(steamID, AntiCrashReason.UnusedRequestGameStartedCooldownPacket);
						return false;
					}
					if ((int)val3 == 23)
					{
						AntiCrasher.Instance.Flag(steamID, AntiCrashReason.UnusedTryBuyItemPacket);
						return false;
					}
					if ((int)val3 == 26)
					{
						AntiCrasher.Instance.Flag(steamID, AntiCrashReason.UnusedPlayerReloadPacket);
						return false;
					}
				}
			}
			else
			{
				if (!Enum.IsDefined(typeof(EnumPublicSealedvawesepilorelogasespUnique), num))
				{
					AntiCrasher.Instance.Flag(steamID, AntiCrashReason.InvalidServerPacketType);
					return false;
				}
				if (steamID != SteamMatchmaking.GetLobbyOwner(MonoBehaviourPublicObInUIgaStCSBoStcuCSUnique.Instance.currentLobby).m_SteamID)
				{
					if (num == 13 || num == 14)
					{
						AntiCrasher.Instance.Flag(steamID, AntiCrashReason.UnauthorizedServerPacketFromNonHost);
					}
					return false;
				}
				if (num == 39)
				{
					if (cbSize < 16)
					{
						return false;
					}
					ulong clientId = PacketExtensions.ReadUlong(val2, true);
					AntiCrasher.Instance.Flag(clientId, AntiCrashReason.UnusedPlayerReloadPacketFromHost, banOffender: false);
					return false;
				}
			}
			return true;
		}

		[HarmonyPatch(typeof(MonoBehaviourPublicInStInpabyDiInpaby2Unique), "Method_Private_Static_Void_SteamNetworkingMessage_t_Int32_0")]
		[HarmonyFinalizer]
		internal static Exception FinalSteamPacketManagerHandlePacket(SteamNetworkingMessage_t param_0, int param_1, Exception __exception)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Expected O, but got Unknown
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			if (__exception != null)
			{
				ManualLogSource log = ((BasePlugin)AntiCrasher.Instance).Log;
				bool flag = default(bool);
				BepInExErrorLogInterpolatedStringHandler val = new BepInExErrorLogInterpolatedStringHandler(51, 4, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("An exception occurred handling a ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<EnumNPublicSealedvaTo3vToUnique>((EnumNPublicSealedvaTo3vToUnique)param_1);
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" packet from ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(SteamFriends.GetFriendPersonaName(param_0.m_identityPeer.GetSteamID()));
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" (");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<ulong>(param_0.m_identityPeer.GetSteamID64());
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("):\n");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<Exception>(__exception);
				}
				log.LogError(val);
			}
			return null;
		}
	}
	internal static class InvalidHelpers
	{
		internal static bool IsInvalid(this float value)
		{
			if (!float.IsNaN(value) && !float.IsInfinity(value) && value != float.MaxValue)
			{
				return value == float.MinValue;
			}
			return true;
		}

		internal static bool IsInvalid(this Vector3 value)
		{
			//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)
			if (!value.x.IsInvalid() && !value.y.IsInvalid())
			{
				return value.z.IsInvalid();
			}
			return true;
		}
	}
	internal static class ServerHandlePatches
	{
		[HarmonyPatch(typeof(MonoBehaviourPublicPlVoUI9GaVoUI9UsPlUnique), "PlayerPosition")]
		[HarmonyPrefix]
		[HarmonyPriority(int.MaxValue)]
		internal static bool PreServerHandlePlayerPosition(ulong param_0, ObjectPublicIDisposableLi1ByInByBoUnique param_1)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			int num = PacketExtensions[param_1];
			if (PacketExtensions.ReadVector3(param_1, true).IsInvalid())
			{
				AntiCrasher.Instance.Flag(param_0, AntiCrashReason.InvalidPlayerPositionPacket);
				PacketExtensions[param_1] = num;
				return false;
			}
			PacketExtensions[param_1] = num;
			return true;
		}

		[HarmonyPatch(typeof(MonoBehaviourPublicPlVoUI9GaVoUI9UsPlUnique), "PlayerRotation")]
		[HarmonyPrefix]
		[HarmonyPriority(int.MaxValue)]
		internal static bool PreServerHandlePlayerRotation(ulong param_0, ObjectPublicIDisposableLi1ByInByBoUnique param_1)
		{
			int num = PacketExtensions[param_1];
			float value = PacketExtensions.ReadFloat(param_1, true);
			if (PacketExtensions.ReadFloat(param_1, true).IsInvalid() || value.IsInvalid())
			{
				AntiCrasher.Instance.Flag(param_0, AntiCrashReason.InvalidPlayerRotationPacket);
				PacketExtensions[param_1] = num;
				return false;
			}
			PacketExtensions[param_1] = num;
			return true;
		}

		[HarmonyPatch(typeof(MonoBehaviourPublicPlVoUI9GaVoUI9UsPlUnique), "PlayerAnimation")]
		[HarmonyPrefix]
		[HarmonyPriority(int.MaxValue)]
		internal static bool PreServerHandlePlayerAnimation(ulong param_0, ObjectPublicIDisposableLi1ByInByBoUnique param_1)
		{
			int num = PacketExtensions[param_1];
			int num2 = PacketExtensions.ReadInt(param_1, true);
			if (!Enum.IsDefined(typeof(EnumNPublicSealedvaCrMe3vUnique), num2))
			{
				AntiCrasher.Instance.Flag(param_0, AntiCrashReason.InvalidPlayerAnimationPacket);
				PacketExtensions[param_1] = num;
				return false;
			}
			PacketExtensions[param_1] = num;
			return true;
		}

		[HarmonyPatch(typeof(MonoBehaviourPublicPlVoUI9GaVoUI9UsPlUnique), "CrabDamage")]
		[HarmonyPrefix]
		[HarmonyPriority(int.MaxValue)]
		internal static bool PreServerHandleCrabDamage(ulong param_0, ObjectPublicIDisposableLi1ByInByBoUnique param_1)
		{
			int num = PacketExtensions[param_1];
			int num2 = PacketExtensions.ReadInt(param_1, true);
			int num3 = PacketExtensions.ReadInt(param_1, true);
			ItemData itemById = MonoBehaviourPublicDi2InItidGamoObInUnique.GetItemById(num2);
			if ((Object)(object)itemById == (Object)null || itemById.itemName != "Snowball" || !MonoBehaviourPublicDi2InObInObInUnique.Instance.Contains(num3))
			{
				AntiCrasher.Instance.Flag(param_0, AntiCrashReason.InvalidCrabDamagePacket);
				PacketExtensions[param_1] = num;
				return false;
			}
			MonoBehaviourPublicInidBoskUnique sharedObject = MonoBehaviourPublicDi2InObInObInUnique.Instance.GetSharedObject(num3);
			if ((Object)(object)sharedObject != (Object)null)
			{
				MonoBehaviour1PublicAbstractItitBoGapiTrrileTrObUnique component = ((Component)sharedObject).GetComponent<MonoBehaviour1PublicAbstractItitBoGapiTrrileTrObUnique>();
				if ((Object)(object)component != (Object)null && component.itemData.itemID != num2)
				{
					AntiCrasher.Instance.Flag(param_0, AntiCrashReason.InvalidCrabDamagePacket);
					PacketExtensions[param_1] = num;
					return false;
				}
			}
			PacketExtensions[param_1] = num;
			return true;
		}

		[HarmonyPatch(typeof(MonoBehaviourPublicPlVoUI9GaVoUI9UsPlUnique), "PlayerDamage")]
		[HarmonyPrefix]
		[HarmonyPriority(int.MaxValue)]
		internal static bool PreServerHandlePlayerDamage(ulong param_0, ObjectPublicIDisposableLi1ByInByBoUnique param_1)
		{
			//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_001f: 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_0028: Unknown result type (might be due to invalid IL or missing references)
			int num = PacketExtensions[param_1];
			PacketExtensions.ReadUlong(param_1, true);
			PacketExtensions.ReadInt(param_1, true);
			Vector3 val = PacketExtensions.ReadVector3(param_1, true);
			if (val.IsInvalid() || (val != Vector3.zero && (((Vector3)(ref val)).magnitude > 1.0001f || ((Vector3)(ref val)).magnitude < 0.9999f)))
			{
				AntiCrasher.Instance.Flag(param_0, AntiCrashReason.InvalidPlayerDamagePacket);
				PacketExtensions[param_1] = num;
				return false;
			}
			PacketExtensions[param_1] = num;
			return true;
		}
	}
	internal static class ClientHandlePatches
	{
		[HarmonyPatch(typeof(MonoBehaviourPublicUIInUIByUIUnique), "PlayerPosition")]
		[HarmonyPrefix]
		[HarmonyPriority(int.MaxValue)]
		internal static bool PreClientHandlePlayerPosition(ObjectPublicIDisposableLi1ByInByBoUnique param_0)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			int num = PacketExtensions[param_0];
			ulong clientId = PacketExtensions.ReadUlong(param_0, true);
			if (PacketExtensions.ReadVector3(param_0, true).IsInvalid())
			{
				AntiCrasher.Instance.Flag(clientId, AntiCrashReason.InvalidPlayerPositionPacketFromHost, banOffender: false);
				PacketExtensions[param_0] = num;
				return false;
			}
			PacketExtensions[param_0] = num;
			return true;
		}

		[HarmonyPatch(typeof(MonoBehaviourPublicUIInUIByUIUnique), "PlayerRotation")]
		[HarmonyPrefix]
		[HarmonyPriority(int.MaxValue)]
		internal static bool PreClientHandlePlayerRotation(ObjectPublicIDisposableLi1ByInByBoUnique param_0)
		{
			int num = PacketExtensions[param_0];
			ulong clientId = PacketExtensions.ReadUlong(param_0, true);
			float value = PacketExtensions.ReadFloat(param_0, true);
			if (PacketExtensions.ReadFloat(param_0, true).IsInvalid() || value.IsInvalid())
			{
				AntiCrasher.Instance.Flag(clientId, AntiCrashReason.InvalidPlayerRotationPacketFromHost, banOffender: false);
				PacketExtensions[param_0] = num;
				return false;
			}
			PacketExtensions[param_0] = num;
			return true;
		}

		[HarmonyPatch(typeof(MonoBehaviourPublicUIInUIByUIUnique), "PlayerAnimation")]
		[HarmonyPrefix]
		[HarmonyPriority(int.MaxValue)]
		internal static bool PreClientHandlePlayerAnimation(ObjectPublicIDisposableLi1ByInByBoUnique param_0)
		{
			int num = PacketExtensions[param_0];
			ulong clientId = PacketExtensions.ReadUlong(param_0, true);
			int num2 = PacketExtensions.ReadInt(param_0, true);
			if (!Enum.IsDefined(typeof(EnumNPublicSealedvaCrMe3vUnique), num2))
			{
				AntiCrasher.Instance.Flag(clientId, AntiCrashReason.InvalidPlayerAnimationPacketFromHost, banOffender: false);
				PacketExtensions[param_0] = num;
				return false;
			}
			PacketExtensions[param_0] = num;
			return true;
		}

		[HarmonyPatch(typeof(MonoBehaviourPublicUIInUIByUIUnique), "PlayerDamage")]
		[HarmonyPrefix]
		[HarmonyPriority(int.MaxValue)]
		internal static bool PreClientHandlePlayerDamage(ObjectPublicIDisposableLi1ByInByBoUnique param_0)
		{
			//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_0027: 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_002f: 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)
			int num = PacketExtensions[param_0];
			ulong clientId = PacketExtensions.ReadUlong(param_0, true);
			PacketExtensions.ReadUlong(param_0, true);
			PacketExtensions.ReadInt(param_0, true);
			Vector3 val = PacketExtensions.ReadVector3(param_0, true);
			if (val.IsInvalid() || (val != Vector3.zero && (((Vector3)(ref val)).magnitude > 1.0001f || ((Vector3)(ref val)).magnitude < 0.9999f)))
			{
				AntiCrasher.Instance.Flag(clientId, AntiCrashReason.InvalidPlayerDamagePacketFromHost, banOffender: false);
				PacketExtensions[param_0] = num;
				return !val.IsInvalid();
			}
			PacketExtensions[param_0] = num;
			return true;
		}
	}
	internal static class ChatboxPatches
	{
		[HarmonyPatch(typeof(MonoBehaviourPublicRaovTMinTemeColoonCoUnique), "ForceMessage")]
		[HarmonyPostfix]
		internal static void PostChatboxForceMessage(MonoBehaviourPublicRaovTMinTemeColoonCoUnique __instance)
		{
			if (((TMP_Text)__instance.messages).text.Length > ChatboxExtensions[__instance])
			{
				TextMeshProUGUI messages = __instance.messages;
				string text = ((TMP_Text)__instance.messages).text;
				int num = ChatboxExtensions[__instance];
				int length = text.Length;
				int num2 = length - num;
				((TMP_Text)messages).text = text.Substring(num2, length - num2);
			}
		}
	}
	internal static class PlayerChatDropPatches
	{
		private static bool _shouldNotParse = false;

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

		[HarmonyPatch(typeof(MonoBehaviourPublicStCaSt1ObSthaUIStmaUnique), "PlayerChatDrop")]
		[HarmonyPrefix]
		internal static void PreDeobf_SteamInventoryPlayerChatDrop()
		{
			_shouldNotParse = true;
		}

		[HarmonyPatch(typeof(MonoBehaviourPublicStCaSt1ObSthaUIStmaUnique), "PlayerChatDrop")]
		[HarmonyPostfix]
		internal static void PostDeobf_SteamInventoryPlayerChatDrop()
		{
			_shouldNotParse = false;
		}

		[HarmonyPatch(typeof(SteamFriends), "GetFriendPersonaName")]
		[HarmonyPostfix]
		internal static void PostSteamFriendsGetFriendPersonaName(ref string __result)
		{
			if (_shouldNotParse)
			{
				__result = "<noparse>" + __result.Replace("noparse", "") + "</noparse>";
			}
		}

		[HarmonyPatch(typeof(MonoBehaviourPublicPlVoUI9GaVoUI9UsPlUnique), "PlayerDropSerialized")]
		[HarmonyPrefix]
		[HarmonyPriority(int.MaxValue)]
		internal static bool PreServerHandlePlayerDropSerialized(ulong param_0)
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			if (_recentDrops.Contains(param_0))
			{
				return false;
			}
			_recentDrops.Add(param_0);
			MonoBehaviourExtensions.StartCoroutine((MonoBehaviour)(object)MonoBehaviourPublicObInVoAwVoVoVoVoVoVoUnique.Instance, CoroChatDropCooldown(param_0));
			string friendPersonaName = SteamFriends.GetFriendPersonaName(new CSteamID(param_0));
			int num = friendPersonaName.IndexOf('<');
			if (num == -1 || num + 1 >= friendPersonaName.Length)
			{
				return true;
			}
			return friendPersonaName.IndexOf(">", num + 1) == -1;
		}

		private static IEnumerator CoroChatDropCooldown(ulong clientId)
		{
			yield return (object)new WaitForSeconds(1f);
			_recentDrops.Remove(clientId);
		}
	}
	internal static class AntiShadowModPatches
	{
		[HarmonyPatch(typeof(MonoBehaviourPublicGapaTrconaGaDi2UIObUnique), "UpdateList")]
		[HarmonyPostfix]
		internal static void PostPlayerListUpdateList(MonoBehaviourPublicGapaTrconaGaDi2UIObUnique __instance)
		{
			//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_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: 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_00e2: 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_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			if (!MonoBehaviourPublicObInUIgaStCSBoStcuCSUnique.Instance.IsLobbyOwner())
			{
				return;
			}
			foreach (ObjectPublicBoInBoCSItBoInSiBySiUnique item in (Il2CppArrayBase<ObjectPublicBoInBoCSItBoInSiBySiUnique>)(object)MonoBehaviourPublicCSDi2UIInstObUIloDiUnique.Instance.GetClients())
			{
				if (!(item.field_Public_CSteamID_0 == CSteamID.Nil) && !__instance.field_Private_Dictionary_2_UInt64_MonoBehaviourPublicRabaicRaTeusscTepiObUnique_0.ContainsKey(item.field_Public_CSteamID_0.m_SteamID))
				{
					MonoBehaviourPublicRabaicRaTeusscTepiObUnique component = Object.Instantiate<GameObject>(__instance.namePrefab, __instance.contentParent).GetComponent<MonoBehaviourPublicRabaicRaTeusscTepiObUnique>();
					__instance.field_Private_Dictionary_2_UInt64_MonoBehaviourPublicRabaicRaTeusscTepiObUnique_0.Add(item.field_Public_CSteamID_0.m_SteamID, component);
					((TMP_Text)component.username).text = MonoBehaviourPublicRaovTMinTemeColoonCoUnique.RemoveRichText(SteamFriends.GetFriendPersonaName(item.field_Public_CSteamID_0));
					if (MonoBehaviourPublicDi2UIObacspDi2UIObUnique.Instance.activePlayers.ContainsKey(item.field_Public_CSteamID_0.m_SteamID))
					{
						component.SetPlayer(MonoBehaviourPublicDi2UIObacspDi2UIObUnique.Instance.activePlayers[item.field_Public_CSteamID_0.m_SteamID]);
					}
					else
					{
						component.SetSpectator(item.field_Public_CSteamID_0.m_SteamID);
					}
					((Graphic)component.background).color = Color.yellow;
					((Graphic)component.icon).color = Color.yellow;
				}
			}
		}
	}
	[BepInPlugin("lammas123.AntiCrasher", "AntiCrasher", "1.1.1")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public sealed class AntiCrasher : BasePlugin
	{
		internal static AntiCrasher Instance;

		internal bool chatFlags = true;

		internal bool persistentDataBan;

		internal bool packetLogging;

		public override void Load()
		{
			//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_00d1: 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_00f1: 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_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0131: Expected O, but got Unknown
			CultureInfo.CurrentCulture = CultureInfo.InvariantCulture;
			CultureInfo.CurrentUICulture = CultureInfo.InvariantCulture;
			CultureInfo.DefaultThreadCurrentCulture = CultureInfo.InvariantCulture;
			CultureInfo.DefaultThreadCurrentUICulture = CultureInfo.InvariantCulture;
			Instance = this;
			chatFlags = ((BasePlugin)this).Config.Bind<bool>("AntiCrasher", "ChatFlags", true, "Whether to notify you about the Anti Crasher being flagged in the chatbox or not. You'll still be able to check for flags in the console or LogOutput.txt.").Value;
			persistentDataBan = ((BasePlugin)this).Config.Bind<bool>("AntiCrasher", "PersistentDataBans", false, "If flagged crashers should be permanently banned via PersistentData if it's installed.").Value;
			packetLogging = ((BasePlugin)this).Config.Bind<bool>("AntiCrasher", "PacketLogging", false, "If all received packets should be logged to PacketLog.txt at the root of your BepInEx directory.").Value;
			LobbyTracker.Init();
			SessionVerifier.Init();
			if (packetLogging)
			{
				PacketLogger.Init();
			}
			Harmony val = new Harmony("AntiCrasher");
			val.PatchAll(typeof(HandlePacketPatches));
			val.PatchAll(typeof(ServerHandlePatches));
			val.PatchAll(typeof(ClientHandlePatches));
			val.PatchAll(typeof(ChatboxPatches));
			val.PatchAll(typeof(PlayerChatDropPatches));
			val.PatchAll(typeof(AntiShadowModPatches));
			ManualLogSource log = ((BasePlugin)this).Log;
			bool flag = default(bool);
			BepInExInfoLogInterpolatedStringHandler val2 = new BepInExInfoLogInterpolatedStringHandler(15, 2, ref flag);
			if (flag)
			{
				((BepInExLogInterpolatedStringHandler)val2).AppendLiteral("Initialized [");
				((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<string>("AntiCrasher");
				((BepInExLogInterpolatedStringHandler)val2).AppendLiteral(" ");
				((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<string>("1.1.1");
				((BepInExLogInterpolatedStringHandler)val2).AppendLiteral("]");
			}
			log.LogInfo(val2);
		}

		internal void Flag(ulong clientId, AntiCrashReason reason, bool banOffender = true)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Expected O, but got Unknown
			//IL_0021: 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_00c1: 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_00d3: 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)
			ManualLogSource log = ((BasePlugin)this).Log;
			bool flag = default(bool);
			BepInExInfoLogInterpolatedStringHandler val = new BepInExInfoLogInterpolatedStringHandler(17, 3, ref flag);
			if (flag)
			{
				((BepInExLogInterpolatedStringHandler)val).AppendLiteral("Flagged ");
				((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(SteamFriends.GetFriendPersonaName(new CSteamID(clientId)));
				((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" (");
				((BepInExLogInterpolatedStringHandler)val).AppendFormatted<ulong>(clientId);
				((BepInExLogInterpolatedStringHandler)val).AppendLiteral(") for: ");
				((BepInExLogInterpolatedStringHandler)val).AppendFormatted<AntiCrashReason>(reason);
			}
			log.LogInfo(val);
			if (chatFlags && Object.op_Implicit((Object)(object)MonoBehaviourPublicRaovTMinTemeColoonCoUnique.Instance))
			{
				MonoBehaviourPublicRaovTMinTemeColoonCoUnique.Instance.AppendMessage(0uL, reason.ToString(), "AntiCrasher Flagged " + SteamFriends.GetFriendPersonaName(new CSteamID(clientId)) + " for");
			}
			if (!banOffender || !MonoBehaviourPublicObInUIgaStCSBoStcuCSUnique.Instance.IsLobbyOwner() || clientId == SteamUser.GetSteamID().m_SteamID)
			{
				if (banOffender && clientId != SteamUser.GetSteamID().m_SteamID)
				{
					if (clientId == MonoBehaviourPublicObInUIgaStCSBoStcuCSUnique.Instance.originalLobbyOwnerId.m_SteamID)
					{
						MonoBehaviourPublicObInUIgaStCSBoStcuCSUnique.Instance.LeaveLobby();
						MonoBehaviourPublicGaprLi1ObGaprInUnique.Instance.NewPrompt("Anti Crasher", $"The host was flagged for {reason}, left lobby.");
					}
					else
					{
						LobbyTracker.blockedMembers.Add(clientId);
						MonoBehaviourPublicObInUIgaStCSBoStcuCSUnique.Instance.StopP2P(new CSteamID(clientId));
					}
				}
			}
			else
			{
				if (persistentDataBan && PersistentDataCompatibility.Enabled)
				{
					PersistentDataCompatibility.SetClientData(clientId, "Banned", $"[AntiCrasher] detected: {reason}");
				}
				LobbyTracker.blockedMembers.Add(clientId);
				MonoBehaviourPublicCSDi2UIInstObUIloDiUnique.Instance.BanPlayer(clientId);
			}
		}
	}
	internal enum AntiCrashReason
	{
		InvalidPacketLength,
		InvalidClientPacketType,
		InvalidServerPacketType,
		UnauthorizedServerPacketFromNonHost,
		UnusedPingPongPacket,
		UnusedColorChangeRequestPacket,
		UnusedRequestGameStartedCooldownPacket,
		UnusedTryBuyItemPacket,
		UnusedPlayerReloadPacket,
		UnusedPlayerReloadPacketFromHost,
		InvalidPlayerPositionPacket,
		InvalidPlayerRotationPacket,
		InvalidPlayerAnimationPacket,
		InvalidCrabDamagePacket,
		InvalidPlayerDamagePacket,
		InvalidPlayerPositionPacketFromHost,
		InvalidPlayerRotationPacketFromHost,
		InvalidPlayerAnimationPacketFromHost,
		InvalidPlayerDamagePacketFromHost
	}
	internal static class SessionVerifier
	{
		internal static void Init()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			new Harmony("AntiCrasher.SessionVerifier").PatchAll(typeof(SessionVerifier));
		}

		internal static bool IsValid(ulong clientId)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			if (clientId != SteamUser.GetSteamID().m_SteamID)
			{
				if (LobbyTracker.currentMembers.Contains(clientId))
				{
					return !LobbyTracker.blockedMembers.Contains(clientId);
				}
				return false;
			}
			return true;
		}

		[HarmonyPatch(typeof(MonoBehaviourPublicObInUIgaStCSBoStcuCSUnique), "NewAcceptP2P", new Type[] { typeof(CSteamID) })]
		[HarmonyPrefix]
		[HarmonyPriority(int.MaxValue)]
		internal static bool PreSteamManagerNewAcceptP2P(CSteamID param_1)
		{
			//IL_0000: 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)
			if (IsValid(param_1.m_SteamID))
			{
				return true;
			}
			if (AntiCrasher.Instance.packetLogging)
			{
				PacketLogger.EnqueuePacket(param_1.m_SteamID, -1, -1, Array.Empty<byte>());
			}
			return false;
		}

		[HarmonyPatch(typeof(MonoBehaviourPublicObInUIgaStCSBoStcuCSUnique), "NewAcceptP2P", new Type[] { typeof(SteamNetworkingIdentity) })]
		[HarmonyPrefix]
		[HarmonyPriority(int.MaxValue)]
		internal static bool PreSteamManagerNewAcceptP2P(SteamNetworkingIdentity param_1)
		{
			if (IsValid(param_1.GetSteamID64()))
			{
				return true;
			}
			if (AntiCrasher.Instance.packetLogging)
			{
				PacketLogger.EnqueuePacket(param_1.GetSteamID64(), -1, -1, Array.Empty<byte>());
			}
			return false;
		}
	}
	internal static class TestAntiCrash
	{
		internal static void Test()
		{
		}
	}
	public static class MyPluginInfo
	{
		public const string PLUGIN_GUID = "lammas123.AntiCrasher";

		public const string PLUGIN_NAME = "AntiCrasher";

		public const string PLUGIN_VERSION = "1.1.1";
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
	internal sealed class IgnoresAccessChecksToAttribute : Attribute
	{
		public IgnoresAccessChecksToAttribute(string assemblyName)
		{
		}
	}
}