using System;
using System.CodeDom.Compiler;
using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.IO;
using System.IO.Compression;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;
using System.Reflection.Emit;
using System.Resources;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Cryptography;
using System.Security.Permissions;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading;
using System.Threading.Tasks;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using BetterEmote.AssetScripts;
using BunkbedRevive;
using CSync.Extensions;
using CSync.Lib;
using CustomItemBehaviourLibrary.AbstractItems;
using Dawn.Internal;
using Dawn.Utils;
using Dissonance.Integrations.Unity_NFGO;
using DunGen;
using DunGen.Tags;
using FacilityMeltdown.API;
using GameNetcodeStuff;
using GeneralImprovements;
using HarmonyLib;
using LCPeeper;
using LethalBots.AI;
using LethalBots.AI.AIStates;
using LethalBots.Configs;
using LethalBots.Constants;
using LethalBots.Enums;
using LethalBots.Inputs;
using LethalBots.Managers;
using LethalBots.NetcodePatcher;
using LethalBots.NetworkSerializers;
using LethalBots.Patches.EnemiesPatches;
using LethalBots.Patches.GameEnginePatches;
using LethalBots.Patches.MapHazardsPatches;
using LethalBots.Patches.MapPatches;
using LethalBots.Patches.ModPatches.AdditionalNetworking;
using LethalBots.Patches.ModPatches.BetterEmotes;
using LethalBots.Patches.ModPatches.BunkbedRevive;
using LethalBots.Patches.ModPatches.DawnLib;
using LethalBots.Patches.ModPatches.LCVR;
using LethalBots.Patches.ModPatches.LethalPhones;
using LethalBots.Patches.ModPatches.LethalProgression;
using LethalBots.Patches.ModPatches.ModelRplcmntAPI;
using LethalBots.Patches.ModPatches.MoreEmotes;
using LethalBots.Patches.ModPatches.Peepers;
using LethalBots.Patches.ModPatches.ReviveCompany;
using LethalBots.Patches.ModPatches.ShowCapacity;
using LethalBots.Patches.ModPatches.TooManyEmotes;
using LethalBots.Patches.ModPatches.UsualScrap;
using LethalBots.Patches.ModPatches.Zaprillator;
using LethalBots.Patches.NpcPatches;
using LethalBots.Patches.ObjectsPatches;
using LethalBots.SaveAdapter;
using LethalBots.Utils;
using LethalBots.Utils.Helpers;
using LethalCompanyInputUtils.Api;
using LethalInternship.AI;
using LethalInternship.Managers;
using LethalLib.Modules;
using LethalMin;
using Microsoft.CodeAnalysis;
using ModelReplacement;
using ModelReplacement.Monobehaviors;
using ModelReplacement.Patches;
using MoreCompany;
using MoreCompany.Cosmetics;
using MoreEmotes.Patch;
using MoreEmotes.Scripts;
using Newtonsoft.Json;
using OPJosMod.ReviveCompany;
using OPJosMod.ReviveCompany.CustomRpc;
using ReservedItemSlotCore;
using ReservedItemSlotCore.Data;
using ReservedItemSlotCore.Patches;
using Scoops.gameobjects;
using Scoops.misc;
using Scoops.patch;
using Scoops.service;
using SpeechRecognitionAPI;
using Steamworks;
using TMPro;
using TooManyEmotes;
using TooManyEmotes.Networking;
using TooManyEmotes.Patches;
using Unity.AI.Navigation;
using Unity.Netcode;
using UnityEngine;
using UnityEngine.AI;
using UnityEngine.Animations.Rigging;
using UnityEngine.Audio;
using UnityEngine.Events;
using UnityEngine.InputSystem;
using UnityEngine.Networking;
using UnityEngine.Rendering;
using UnityEngine.SceneManagement;
using UnityEngine.UI;
using UsualScrap.Behaviors;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("LethalBots")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("6.1.3.0")]
[assembly: AssemblyInformationalVersion("6.1.3+ea30df10e3d6bee9373f101ea70f81201d684c45")]
[assembly: AssemblyProduct("LethalBots")]
[assembly: AssemblyTitle("LethalBots")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("6.1.3.0")]
[assembly: TypeForwardedTo(typeof(AllowNullAttribute))]
[assembly: TypeForwardedTo(typeof(DisallowNullAttribute))]
[assembly: TypeForwardedTo(typeof(MaybeNullAttribute))]
[assembly: TypeForwardedTo(typeof(MaybeNullWhenAttribute))]
[assembly: TypeForwardedTo(typeof(NotNullAttribute))]
[assembly: TypeForwardedTo(typeof(NotNullIfNotNullAttribute))]
[assembly: TypeForwardedTo(typeof(NotNullWhenAttribute))]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
[module: NetcodePatchedAssembly]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class IsUnmanagedAttribute : Attribute
	{
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

		public NullableAttribute(byte P_0)
		{
			NullableFlags = new byte[1] { P_0 };
		}

		public NullableAttribute(byte[] P_0)
		{
			NullableFlags = P_0;
		}
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.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 LethalBots
{
	[BepInPlugin("T-Rizzle.LethalBots", "LethalBots", "6.1.3")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class Plugin : BaseUnityPlugin
	{
		public const string ModGUID = "T-Rizzle.LethalBots";

		public static AssetBundle ModAssets;

		public static AssetBundle ShipOrbitNavMeshAssets;

		internal static string DirectoryName;

		internal static EnemyType LethalBotNPCPrefab;

		internal static GameObject ShipOrbitNavMeshPrefab;

		internal static int PluginIrlPlayersCount;

		internal static ManualLogSource Logger;

		internal static Config Config;

		internal static LethalBotsInputs InputActionsInstance;

		internal static bool IsModSpeechRecognitionAPILoaded;

		internal static bool IsModTooManyEmotesLoaded;

		internal static bool IsModModelReplacementAPILoaded;

		internal static bool IsModCustomItemBehaviourLibraryLoaded;

		internal static bool IsModMoreCompanyLoaded;

		internal static bool IsModReviveCompanyLoaded;

		internal static bool IsModBunkbedReviveLoaded;

		internal static bool IsModZaprillatorLoaded;

		internal static bool IsModLethalMinLoaded;

		internal static bool IsModLethalInternsLoaded;

		internal static bool IsModFacilityMeltdownLoaded;

		internal static bool IsModNavmeshInCompanyLoaded;

		internal static bool IsModReservedItemSlotCoreLoaded;

		internal static bool IsModLethalPhonesLoaded;

		internal static bool IsModGeneralImprovementsLoaded;

		internal static bool IsModDawnLibLoaded;

		internal static bool IsModUsualScrapLoaded;

		private readonly Harmony _harmony = new Harmony("T-Rizzle.LethalBots");

		private void Awake()
		{
			string text = "lethalbotnpcmodassets";
			string path = "ship_orbit_navmesh";
			DirectoryName = Path.GetDirectoryName(((BaseUnityPlugin)this).Info.Location);
			Logger = ((BaseUnityPlugin)this).Logger;
			Config = new Config(((BaseUnityPlugin)this).Config);
			InputActionsInstance = new LethalBotsInputs();
			InitializeNetworkBehaviours();
			ModAssets = AssetBundle.LoadFromFile(Path.Combine(DirectoryName, text));
			if ((Object)(object)ModAssets == (Object)null)
			{
				Logger.LogFatal((object)"Unknown to load custom assets.");
				return;
			}
			LethalBotNPCPrefab = ModAssets.LoadAsset<EnemyType>("LethalBotNPC");
			if ((Object)(object)LethalBotNPCPrefab == (Object)null)
			{
				Logger.LogInfo((object)"Failed to directly load LethalBotNPC, manually searching asset bundle instead!");
				Object[] array = ModAssets.LoadAllAssets();
				for (int i = 0; i < array.Length; i++)
				{
					Logger.LogInfo((object)$"Found {array[i]} in asset bundle");
					Object obj = array[i];
					EnemyType val = (EnemyType)(object)((obj is EnemyType) ? obj : null);
					if (val != null)
					{
						LethalBotNPCPrefab = val;
						break;
					}
				}
			}
			if ((Object)(object)LethalBotNPCPrefab == (Object)null)
			{
				Logger.LogFatal((object)"LethalBotNPC prefab failed to load.");
				return;
			}
			foreach (Transform item in (from x in LethalBotNPCPrefab.enemyPrefab.GetComponentsInChildren<Transform>()
				where (Object)(object)x.parent != (Object)null && ((Object)x.parent).name == "LethalBotNPCObj" && ((Object)x).name != "Collision" && ((Object)x).name != "TurnCompass" && ((Object)x).name != "CreatureSFX" && ((Object)x).name != "CreatureVoice"
				select x).ToList())
			{
				Object.DestroyImmediate((Object)(object)((Component)item).gameObject);
			}
			byte[] value = MD5.Create().ComputeHash(Encoding.UTF8.GetBytes(Assembly.GetCallingAssembly().GetName().Name + ((Object)((Component)this).gameObject).name + text));
			uint num = BitConverter.ToUInt32(value, 0);
			Type typeFromHandle = typeof(NetworkObject);
			FieldInfo field = typeFromHandle.GetField("GlobalObjectIdHash", BindingFlags.Instance | BindingFlags.NonPublic);
			NetworkObject component = LethalBotNPCPrefab.enemyPrefab.GetComponent<NetworkObject>();
			field.SetValue(component, num);
			ShipOrbitNavMeshAssets = AssetBundle.LoadFromFile(Path.Combine(DirectoryName, path));
			if ((Object)(object)ShipOrbitNavMeshAssets == (Object)null)
			{
				Logger.LogFatal((object)"Unknown to load custom ship navmesh assests.");
				return;
			}
			ShipOrbitNavMeshPrefab = ShipOrbitNavMeshAssets.LoadAsset<GameObject>("ShipNavMeshColliders");
			if ((Object)(object)ShipOrbitNavMeshPrefab == (Object)null)
			{
				Logger.LogFatal((object)"ShipOrbitNavMesh prefab failed to load.");
				return;
			}
			NetworkPrefabs.RegisterNetworkPrefab(LethalBotNPCPrefab.enemyPrefab);
			InitPluginManager();
			PatchBaseGame();
			PatchOtherMods();
			Logger.LogInfo((object)"Plugin LethalBots is loaded!");
		}

		private void PatchBaseGame()
		{
			_harmony.PatchAll(typeof(AudioMixerPatch));
			_harmony.PatchAll(typeof(AudioReverbTriggerPatch));
			_harmony.PatchAll(typeof(DebugPatch));
			_harmony.PatchAll(typeof(GameNetworkManagerPatch));
			_harmony.PatchAll(typeof(HUDManagerPatch));
			_harmony.PatchAll(typeof(NetworkSceneManagerPatch));
			_harmony.PatchAll(typeof(NfgoPlayerPatch));
			_harmony.PatchAll(typeof(NetworkObjectPatch));
			_harmony.PatchAll(typeof(RoundManagerPatch));
			_harmony.PatchAll(typeof(SoundManagerPatch));
			_harmony.PatchAll(typeof(StartOfRoundPatch));
			_harmony.PatchAll(typeof(EnemyAIPatch));
			_harmony.PatchAll(typeof(PlayerControllerBPatch));
			_harmony.PatchAll(typeof(EnemyAICollisionDetect));
			_harmony.PatchAll(typeof(BaboonBirdAIPatch));
			_harmony.PatchAll(typeof(BlobAIPatch));
			_harmony.PatchAll(typeof(BushWolfEnemyPatch));
			_harmony.PatchAll(typeof(ButlerBeesEnemyAIPatch));
			_harmony.PatchAll(typeof(ButlerEnemyAIPatch));
			_harmony.PatchAll(typeof(CadaverBloomAIPatch));
			_harmony.PatchAll(typeof(CadaverGrowthAIPatch));
			_harmony.PatchAll(typeof(CaveDwellerAIPatch));
			_harmony.PatchAll(typeof(CentipedeAIPatch));
			_harmony.PatchAll(typeof(CrawlerAIPatch));
			_harmony.PatchAll(typeof(DressGirlAIPatch));
			_harmony.PatchAll(typeof(FlowermanAIPatch));
			_harmony.PatchAll(typeof(FlowerSnakeEnemyPatch));
			_harmony.PatchAll(typeof(ForestGiantAIPatch));
			_harmony.PatchAll(typeof(GiantKiwiAIPatch));
			_harmony.PatchAll(typeof(JesterAIPatch));
			_harmony.PatchAll(typeof(MaskedPlayerEnemyPatch));
			_harmony.PatchAll(typeof(MouthDogAIPatch));
			_harmony.PatchAll(typeof(NutcrackerEnemyAIPatch));
			_harmony.PatchAll(typeof(PumaAIPatch));
			_harmony.PatchAll(typeof(RadMechAIPatch));
			_harmony.PatchAll(typeof(RadMechMissilePatch));
			_harmony.PatchAll(typeof(RedLocustBeesPatch));
			_harmony.PatchAll(typeof(SandSpiderAIPatch));
			_harmony.PatchAll(typeof(SandWormAIPatch));
			_harmony.PatchAll(typeof(SpringManAIPatch));
			_harmony.PatchAll(typeof(LandminePatch));
			_harmony.PatchAll(typeof(QuicksandTriggerPatch));
			_harmony.PatchAll(typeof(SpikeRoofTrapPatch));
			_harmony.PatchAll(typeof(TurretPatch));
			_harmony.PatchAll(typeof(AnimatedObjectFloatSetterPatch));
			_harmony.PatchAll(typeof(CompanyMonsterCollisionDetectPatch));
			_harmony.PatchAll(typeof(DoorLockPatch));
			_harmony.PatchAll(typeof(InteractTriggerPatch));
			_harmony.PatchAll(typeof(OutOfBoundsTriggerPatch));
			_harmony.PatchAll(typeof(ShipTeleporterPatch));
			_harmony.PatchAll(typeof(VehicleControllerPatch));
			_harmony.PatchAll(typeof(DepositItemsDeskPatch));
			_harmony.PatchAll(typeof(CaveDwellerPhysicsPropPatch));
			_harmony.PatchAll(typeof(DeadBodyInfoPatch));
			_harmony.PatchAll(typeof(GrabbableObjectPatch));
			_harmony.PatchAll(typeof(RagdollGrabbableObjectPatch));
			_harmony.PatchAll(typeof(ShotgunItemPatch));
			_harmony.PatchAll(typeof(SprayPaintItemPatch));
			_harmony.PatchAll(typeof(StunGrenadeItemPatch));
			_harmony.PatchAll(typeof(TetraChemicalItemPatch));
		}

		private void PatchOtherMods()
		{
			//IL_0213: Unknown result type (might be due to invalid IL or missing references)
			//IL_0221: Expected O, but got Unknown
			//IL_0250: Unknown result type (might be due to invalid IL or missing references)
			//IL_025c: Expected O, but got Unknown
			//IL_028b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0297: Expected O, but got Unknown
			//IL_03a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ad: Expected O, but got Unknown
			//IL_03dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_03eb: Expected O, but got Unknown
			//IL_0457: Unknown result type (might be due to invalid IL or missing references)
			//IL_0465: Expected O, but got Unknown
			//IL_0498: Unknown result type (might be due to invalid IL or missing references)
			//IL_04a6: Expected O, but got Unknown
			//IL_04d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_04e1: Expected O, but got Unknown
			//IL_050e: Unknown result type (might be due to invalid IL or missing references)
			//IL_051c: Expected O, but got Unknown
			//IL_0549: Unknown result type (might be due to invalid IL or missing references)
			//IL_0557: Expected O, but got Unknown
			//IL_0584: Unknown result type (might be due to invalid IL or missing references)
			//IL_0592: Expected O, but got Unknown
			//IL_05df: Unknown result type (might be due to invalid IL or missing references)
			//IL_05ed: Expected O, but got Unknown
			//IL_061a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0628: Expected O, but got Unknown
			//IL_0655: Unknown result type (might be due to invalid IL or missing references)
			//IL_0663: Expected O, but got Unknown
			//IL_0690: Unknown result type (might be due to invalid IL or missing references)
			//IL_069e: Expected O, but got Unknown
			IsModSpeechRecognitionAPILoaded = IsModLoaded("JS03.SpeechRecognitionAPI");
			IsModTooManyEmotesLoaded = IsModLoaded("FlipMods.TooManyEmotes");
			IsModModelReplacementAPILoaded = IsModLoaded("meow.ModelReplacementAPI");
			IsModCustomItemBehaviourLibraryLoaded = IsModLoaded("com.github.WhiteSpike.CustomItemBehaviourLibrary");
			IsModMoreCompanyLoaded = IsModLoaded("me.swipez.melonloader.morecompany");
			IsModReviveCompanyLoaded = IsModLoaded("OpJosMod.ReviveCompany");
			IsModBunkbedReviveLoaded = IsModLoaded("viviko.BunkbedRevive");
			IsModZaprillatorLoaded = IsModLoaded("Zaprillator");
			IsModLethalMinLoaded = IsModLoaded("NoteBoxz.LethalMin");
			IsModLethalInternsLoaded = IsModLoaded("Szumi57.LethalInterns");
			IsModFacilityMeltdownLoaded = IsModLoaded("me.loaforc.facilitymeltdown");
			IsModNavmeshInCompanyLoaded = IsModLoaded("dev.kittenji.NavMeshInCompany");
			IsModReservedItemSlotCoreLoaded = IsModLoaded("FlipMods.ReservedItemSlotCore");
			IsModLethalPhonesLoaded = IsModLoaded("LethalPhones");
			IsModGeneralImprovementsLoaded = IsModLoaded("ShaosilGaming.GeneralImprovements");
			IsModDawnLibLoaded = IsModLoaded("com.github.teamxiaolan.dawnlib");
			IsModUsualScrapLoaded = IsModLoaded("Emil.UsualScrap");
			bool flag = IsModLoaded("MoreEmotes");
			bool flag2 = IsModLoaded("BetterEmotes");
			bool flag3 = IsModLoaded("Piggy.ShowCapacity");
			bool flag4 = IsModLoaded("Stoneman.LethalProgression");
			bool flag5 = IsModLoaded("suskitech.LCAlwaysHearActiveWalkie");
			bool flag6 = IsModLoaded("butterystancakes.lethalcompany.butteryfixes");
			bool flag7 = IsModLoaded("x753.Peepers");
			bool flag8 = IsModLoaded("io.daxcess.lcvr");
			List<string> list = new List<string>();
			string[] files = Directory.GetFiles(Path.GetFullPath(Paths.PatcherPluginPath), "*.dll", SearchOption.AllDirectories);
			foreach (string path in files)
			{
				list.Add(Path.GetFileName(path));
			}
			bool flag9 = IsPreLoaderLoaded("AdditionalNetworking_Preloader.dll", list);
			if (flag)
			{
				_harmony.PatchAll(typeof(MoreEmotesPatch));
			}
			if (flag2)
			{
				_harmony.Patch((MethodBase)AccessTools.Method(AccessTools.TypeByName("BetterEmote.Patches.EmotePatch"), "StartPostfix", (Type[])null, (Type[])null), new HarmonyMethod(typeof(BetterEmotesPatch), "StartPostfix_Prefix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				_harmony.Patch((MethodBase)AccessTools.Method(AccessTools.TypeByName("BetterEmote.Patches.EmotePatch"), "UpdatePostfix", (Type[])null, (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(typeof(BetterEmotesPatch), "UpdatePostfix_Transpiler", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null);
				_harmony.Patch((MethodBase)AccessTools.Method(AccessTools.TypeByName("BetterEmote.Patches.EmotePatch"), "PerformEmotePrefix", (Type[])null, (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(typeof(BetterEmotesPatch), "PerformEmotePrefix_Transpiler", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null);
				_harmony.PatchAll(typeof(BetterEmotesCustomAnimationObjectsPatch));
			}
			if (IsModTooManyEmotesLoaded)
			{
				_harmony.PatchAll(typeof(EmoteControllerPlayerPatch));
				_harmony.PatchAll(typeof(ThirdPersonEmoteControllerPatch));
			}
			if (IsModModelReplacementAPILoaded)
			{
				_harmony.PatchAll(typeof(ModelReplacementPlayerControllerBPatchPatch));
				_harmony.PatchAll(typeof(ModelReplacementAPIPatch));
			}
			if (IsModLethalPhonesLoaded)
			{
				_harmony.PatchAll(typeof(AudioSourceStoragePatch));
				_harmony.PatchAll(typeof(PhoneBehaviorPatch));
				_harmony.PatchAll(typeof(PlayerPhonePatch));
				_harmony.PatchAll(typeof(PlayerPhonePatchPatch));
				PhoneBehaviorPatch.SetupReflectionFields();
			}
			if (flag9)
			{
				_harmony.Patch((MethodBase)AccessTools.Method(AccessTools.TypeByName("AdditionalNetworking.Patches.Inventory.PlayerControllerBPatch"), "OnStart", (Type[])null, (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(typeof(AdditionalNetworkingPatch), "Start_Transpiler", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null);
			}
			if (flag3)
			{
				_harmony.Patch((MethodBase)AccessTools.Method(AccessTools.TypeByName("ShowCapacity.Patches.PlayerControllerBPatch"), "Update_PostFix", (Type[])null, (Type[])null), new HarmonyMethod(typeof(ShowCapacityPatch), "Update_PostFix_Prefix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			}
			if (IsModReviveCompanyLoaded)
			{
				_harmony.PatchAll(typeof(ReviveCompanyGeneralUtilPatch));
			}
			if (IsModBunkbedReviveLoaded)
			{
				_harmony.PatchAll(typeof(BunkbedControllerPatch));
			}
			if (IsModZaprillatorLoaded)
			{
				_harmony.Patch((MethodBase)AccessTools.Method(AccessTools.TypeByName("Zaprillator.Behaviors.RevivablePlayer"), "IShockableWithGun.StopShockingWithGun", (Type[])null, (Type[])null), new HarmonyMethod(typeof(RevivablePlayerPatch), "StopShockingWithGun_Prefix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			}
			if (flag4)
			{
				_harmony.Patch((MethodBase)AccessTools.Method(AccessTools.TypeByName("LethalProgression.Skills.HPRegen"), "HPRegenUpdate", (Type[])null, (Type[])null), new HarmonyMethod(typeof(HPRegenPatch), "HPRegenUpdate_Prefix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				_harmony.Patch((MethodBase)AccessTools.Method(AccessTools.TypeByName("LethalProgression.Skills.Oxygen"), "EnteredWater", (Type[])null, (Type[])null), new HarmonyMethod(typeof(OxygenPatch), "EnteredWater_Prefix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				_harmony.Patch((MethodBase)AccessTools.Method(AccessTools.TypeByName("LethalProgression.Skills.Oxygen"), "LeftWater", (Type[])null, (Type[])null), new HarmonyMethod(typeof(OxygenPatch), "LeftWater_Prefix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				_harmony.Patch((MethodBase)AccessTools.Method(AccessTools.TypeByName("LethalProgression.Skills.Oxygen"), "ShouldDrown", (Type[])null, (Type[])null), new HarmonyMethod(typeof(OxygenPatch), "ShouldDrown_Prefix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				_harmony.Patch((MethodBase)AccessTools.Method(AccessTools.TypeByName("LethalProgression.Skills.Oxygen"), "OxygenUpdate", (Type[])null, (Type[])null), new HarmonyMethod(typeof(OxygenPatch), "OxygenUpdate_Prefix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			}
			if (flag7)
			{
				_harmony.PatchAll(typeof(PeeperAttachHitboxPatch));
			}
			if (flag8)
			{
				_harmony.Patch((MethodBase)AccessTools.Method(AccessTools.TypeByName("LCVR.Patches.Spectating.SpectatorPlayerPatches"), "BeforePlayerDeath", (Type[])null, (Type[])null), new HarmonyMethod(typeof(LCVRPatchesPatch), "BeforePlayerDeath_Prefix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				_harmony.Patch((MethodBase)AccessTools.Method(AccessTools.TypeByName("LCVR.Patches.Spectating.SpectatorPlayerPatches"), "OnPlayerDeath", (Type[])null, (Type[])null), new HarmonyMethod(typeof(LCVRPatchesPatch), "OnPlayerDeath_Prefix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				_harmony.Patch((MethodBase)AccessTools.Method(AccessTools.TypeByName("LCVR.Patches.Items.ShotgunItemPatches"), "DisplaySafetyPatch", (Type[])null, (Type[])null), new HarmonyMethod(typeof(LCVRPatchesPatch), "DisplaySafetyPatch_Prefix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				_harmony.Patch((MethodBase)AccessTools.Method(AccessTools.TypeByName("LCVR.Patches.PlayerControllerPatches"), "AfterDamagePlayer", (Type[])null, (Type[])null), new HarmonyMethod(typeof(LCVRPatchesPatch), "AfterDamagePlayer_Prefix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			}
			if (IsModDawnLibLoaded)
			{
				_harmony.PatchAll(typeof(DawnMoonNetworkerPatch));
			}
			if (IsModUsualScrapLoaded)
			{
				_harmony.PatchAll(typeof(DefibrillatorScriptPatch));
			}
		}

		private bool IsModLoaded(string modGUID)
		{
			bool flag = Chainloader.PluginInfos.ContainsKey(modGUID);
			if (flag)
			{
				LogInfo("Mod compatibility loaded for mod : GUID " + modGUID);
			}
			return flag;
		}

		private bool IsPreLoaderLoaded(string dllFileName, List<string> fileNames)
		{
			bool flag = fileNames.Contains(dllFileName);
			if (flag)
			{
				LogInfo("Mod compatibility loaded for preloader : " + dllFileName);
			}
			return flag;
		}

		private static void InitializeNetworkBehaviours()
		{
			Type[] types = Assembly.GetExecutingAssembly().GetTypes();
			Type[] array = types;
			foreach (Type type in array)
			{
				MethodInfo[] methods = type.GetMethods(BindingFlags.Instance | BindingFlags.Static | BindingFlags.NonPublic);
				MethodInfo[] array2 = methods;
				foreach (MethodInfo methodInfo in array2)
				{
					try
					{
						object[] customAttributes = methodInfo.GetCustomAttributes(typeof(RuntimeInitializeOnLoadMethodAttribute), inherit: false);
						if (customAttributes.Length != 0)
						{
							methodInfo.Invoke(null, null);
						}
					}
					catch
					{
					}
				}
			}
		}

		private static void InitPluginManager()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Expected O, but got Unknown
			GameObject val = new GameObject("PluginManager");
			val.AddComponent<PluginManager>();
			PluginManager.Instance.InitManagers();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void LogDebug(string debugLog)
		{
			if (Config.EnableDebugLog.Value)
			{
				Logger.LogDebug((object)debugLog);
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void LogInfo(string infoLog)
		{
			Logger.LogInfo((object)infoLog);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void LogWarning(string warningLog)
		{
			Logger.LogWarning((object)warningLog);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void LogError(string errorLog)
		{
			Logger.LogError((object)errorLog);
		}
	}
	public static class MyPluginInfo
	{
		public const string PLUGIN_GUID = "LethalBots";

		public const string PLUGIN_NAME = "LethalBots";

		public const string PLUGIN_VERSION = "6.1.3";
	}
}
namespace LethalBots.Utils
{
	internal static class ComponentUtil
	{
		public static void ListAllComponents(GameObject gameObject)
		{
			if ((Object)(object)gameObject == (Object)null)
			{
				return;
			}
			Plugin.LogDebug(" ");
			Plugin.LogDebug("List of components :");
			Component[] components = gameObject.GetComponents(typeof(Component));
			Component[] array = components;
			foreach (Component val in array)
			{
				if (!((Object)(object)val == (Object)null))
				{
					Plugin.LogDebug(((object)val).ToString());
				}
			}
			Plugin.LogDebug("Child components :");
			components = gameObject.GetComponentsInChildren(typeof(Component));
			Component[] array2 = components;
			foreach (Component val2 in array2)
			{
				if (!((Object)(object)val2 == (Object)null))
				{
					Plugin.LogDebug(((object)val2).ToString());
				}
			}
			Plugin.LogDebug("Parent components :");
			components = gameObject.GetComponentsInParent(typeof(Component));
			Component[] array3 = components;
			foreach (Component val3 in array3)
			{
				if (!((Object)(object)val3 == (Object)null))
				{
					Plugin.LogDebug(((object)val3).ToString());
				}
			}
		}

		public static void ListAllColliders(GameObject gameObject)
		{
			if ((Object)(object)gameObject == (Object)null)
			{
				return;
			}
			Plugin.LogDebug(" ");
			Plugin.LogDebug("List of Colliders: ");
			Component[] components = gameObject.GetComponents(typeof(Collider));
			Component[] array = components;
			foreach (Component val in array)
			{
				if (!((Object)(object)val == (Object)null))
				{
					Plugin.LogDebug(((object)val).ToString());
				}
			}
			Plugin.LogDebug("Child Colliders: ");
			components = gameObject.GetComponentsInChildren(typeof(Collider));
			Component[] array2 = components;
			foreach (Component val2 in array2)
			{
				if (!((Object)(object)val2 == (Object)null))
				{
					Plugin.LogDebug(((object)val2).ToString());
				}
			}
			Plugin.LogDebug("Parent Colliders: ");
			components = gameObject.GetComponentsInParent(typeof(Collider));
			Component[] array3 = components;
			foreach (Component val3 in array3)
			{
				if (!((Object)(object)val3 == (Object)null))
				{
					Plugin.LogDebug(((object)val3).ToString());
				}
			}
		}

		public static void SetFieldValue(object obj, string fieldName, object value)
		{
			Type type = obj.GetType();
			FieldInfo field = type.GetField(fieldName, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			field.SetValue(obj, value);
		}

		public static void SetPropertyValue(object obj, string propertyName, object value)
		{
			Type type = obj.GetType();
			PropertyInfo property = type.GetProperty(propertyName, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			property.SetValue(obj, value);
		}

		public static T GetCopyOf<T>(this Component comp, T other) where T : Component
		{
			Type type = ((object)comp).GetType();
			if (type != ((object)other).GetType())
			{
				return default(T);
			}
			BindingFlags bindingAttr = BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic;
			PropertyInfo[] properties = type.GetProperties(bindingAttr);
			PropertyInfo[] array = properties;
			foreach (PropertyInfo propertyInfo in array)
			{
				if (propertyInfo.CanWrite && propertyInfo.CanRead && !(propertyInfo.Name == "name"))
				{
					try
					{
						propertyInfo.SetValue(comp, propertyInfo.GetValue(other, null), null);
					}
					catch
					{
					}
				}
			}
			FieldInfo[] allFields = PropertiesAndFieldsUtils.GetAllFields(type);
			FieldInfo[] array2 = allFields;
			foreach (FieldInfo fieldInfo in array2)
			{
				if (!fieldInfo.IsStatic)
				{
					fieldInfo.SetValue(comp, fieldInfo.GetValue(other));
				}
			}
			return (T)(object)((comp is T) ? comp : null);
		}

		public static T AddCopyOfComponent<T>(this GameObject go, T toAdd) where T : Component
		{
			return ((Component)(object)go.AddComponent<T>()).GetCopyOf(toAdd);
		}

		public static T CopyComponent<T>(T original, GameObject destination) where T : Component
		{
			Type type = ((object)original).GetType();
			Component component = destination.GetComponent(type);
			T val = (T)(object)((component is T) ? component : null);
			if (!Object.op_Implicit((Object)(object)val))
			{
				Component obj = destination.AddComponent(type);
				val = (T)(object)((obj is T) ? obj : null);
			}
			FieldInfo[] allFields = PropertiesAndFieldsUtils.GetAllFields(type);
			FieldInfo[] array = allFields;
			foreach (FieldInfo fieldInfo in array)
			{
				if (!fieldInfo.IsStatic)
				{
					fieldInfo.SetValue(val, fieldInfo.GetValue(original));
				}
			}
			PropertyInfo[] properties = type.GetProperties();
			PropertyInfo[] array2 = properties;
			foreach (PropertyInfo propertyInfo in array2)
			{
				if (propertyInfo.CanWrite && propertyInfo.CanWrite && !(propertyInfo.Name == "name"))
				{
					propertyInfo.SetValue(val, propertyInfo.GetValue(original, null), null);
				}
			}
			return val;
		}
	}
	internal static class DrawUtil
	{
		public static void DrawWhiteLine(LineRenderer? lr, Ray ray, float length)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			DrawLine(lr, ray, length, Color.white);
		}

		public static void DrawLine(LineRenderer? lr, Ray ray, float length, Color color)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			Vector3 origin = ((Ray)(ref ray)).origin;
			Vector3 origin2 = ((Ray)(ref ray)).origin;
			Vector3 direction = ((Ray)(ref ray)).direction;
			DrawLine(lr, origin, origin2 + ((Vector3)(ref direction)).normalized * length, color);
		}

		public static void DrawLine(LineRenderer? lr, Vector3 start, Vector3 end, Color color)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: 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)
			if (!((Object)(object)lr == (Object)null))
			{
				((Renderer)lr).material = new Material(Shader.Find("Legacy Shaders/Particles/Alpha Blended Premultiply"));
				lr.startColor = color;
				lr.endColor = color;
				lr.startWidth = 0.1f;
				lr.endWidth = 0.1f;
				lr.SetPosition(0, start);
				lr.SetPosition(1, end);
			}
		}
	}
	public class LineRendererUtil
	{
		private LineRenderer[] _listLineRenderers;

		private Transform _transformToParent;

		private int _index;

		public LineRendererUtil(int nbMaxLineRenderer, Transform transformToParent)
		{
			_listLineRenderers = (LineRenderer[])(object)new LineRenderer[nbMaxLineRenderer];
			_transformToParent = transformToParent;
		}

		public LineRenderer? GetLineRenderer()
		{
			return null;
		}

		private LineRenderer CreateLineRenderer()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			LineRenderer lineRenderer = new GameObject().AddComponent<LineRenderer>();
			return InitLineRenderer(ref lineRenderer);
		}

		private LineRenderer InitLineRenderer(ref LineRenderer lineRenderer)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			((Component)lineRenderer).gameObject.transform.SetParent(((Component)_transformToParent).transform, false);
			((Component)lineRenderer).gameObject.transform.SetPositionAndRotation(Vector3.zero, Quaternion.identity);
			return lineRenderer;
		}
	}
	internal static class PatchesUtil
	{
		public static readonly FieldInfo FieldInfoWasUnderwaterLastFrame = AccessTools.Field(typeof(PlayerControllerB), "wasUnderwaterLastFrame");

		public static readonly FieldInfo FieldInfoPlayerClientId = AccessTools.Field(typeof(PlayerControllerB), "playerClientId");

		public static readonly FieldInfo FieldInfoPreviousAnimationStateHash = AccessTools.Field(typeof(PlayerControllerB), "previousAnimationStateHash");

		public static readonly FieldInfo FieldInfoCurrentAnimationStateHash = AccessTools.Field(typeof(PlayerControllerB), "currentAnimationStateHash");

		public static readonly FieldInfo FieldInfoTargetPlayer = AccessTools.Field(typeof(EnemyAI), "targetPlayer");

		public static readonly FieldInfo FieldInfoDraggingPlayer = AccessTools.Field(typeof(BushWolfEnemy), "draggingPlayer");

		public static readonly FieldRef<Terminal, bool> usedTerminalThisSessionField = (FieldRef<Terminal, bool>)(object)AccessTools.FieldRefAccess<bool>(typeof(Terminal), "usedTerminalThisSession");

		public static readonly FieldRef<Terminal, bool> syncedTerminalValuesField = (FieldRef<Terminal, bool>)(object)AccessTools.FieldRefAccess<bool>(typeof(Terminal), "syncedTerminalValues");

		public static readonly FieldRef<Terminal, int> totalCostOfItemsField = (FieldRef<Terminal, int>)(object)AccessTools.FieldRefAccess<int>(typeof(Terminal), "totalCostOfItems");

		public static readonly FieldRef<Terminal, bool> broadcastedCodeThisFrameField = (FieldRef<Terminal, bool>)(object)AccessTools.FieldRefAccess<bool>(typeof(Terminal), "broadcastedCodeThisFrame");

		public static readonly FieldRef<Terminal, bool> hasGottenNounField = (FieldRef<Terminal, bool>)(object)AccessTools.FieldRefAccess<bool>(typeof(Terminal), "hasGottenNoun");

		public static readonly FieldRef<Terminal, bool> hasGottenVerbField = (FieldRef<Terminal, bool>)(object)AccessTools.FieldRefAccess<bool>(typeof(Terminal), "hasGottenVerb");

		public static readonly FieldRef<Terminal, InteractTrigger> terminalTriggerField = (FieldRef<Terminal, InteractTrigger>)(object)AccessTools.FieldRefAccess<InteractTrigger>(typeof(Terminal), "terminalTrigger");

		public static readonly FieldRef<ItemDropship, List<int>> itemsToDeliverField = (FieldRef<ItemDropship, List<int>>)(object)AccessTools.FieldRefAccess<List<int>>(typeof(ItemDropship), "itemsToDeliver");

		public static readonly FieldRef<PlayerControllerB, Vector3> positionOfDeathField = (FieldRef<PlayerControllerB, Vector3>)(object)AccessTools.FieldRefAccess<Vector3>(typeof(PlayerControllerB), "positionOfDeath");

		public static readonly FieldRef<PlayerControllerB, float> timeSinceSwitchingSlotsField = (FieldRef<PlayerControllerB, float>)(object)AccessTools.FieldRefAccess<float>(typeof(PlayerControllerB), "timeSinceSwitchingSlots");

		public static readonly FieldRef<PlayerControllerB, float> slimeSlipAudioVolumeSyncField = (FieldRef<PlayerControllerB, float>)(object)AccessTools.FieldRefAccess<float>(typeof(PlayerControllerB), "slimeSlipAudioVolumeSync");

		public static readonly FieldRef<EntranceTeleport, InteractTrigger> triggerScriptField = (FieldRef<EntranceTeleport, InteractTrigger>)(object)AccessTools.FieldRefAccess<InteractTrigger>(typeof(EntranceTeleport), "triggerScript");

		public static readonly MethodInfo PlayerLoadedServerRpcMethod = AccessTools.Method(typeof(StartOfRound), "PlayerLoadedServerRpc", (Type[])null, (Type[])null);

		public static readonly MethodInfo KillPlayerServerRpcMethod = AccessTools.Method(typeof(PlayerControllerB), "KillPlayerServerRpc", (Type[])null, (Type[])null);

		public static readonly MethodInfo AllEntitiesCountMethod = SymbolExtensions.GetMethodInfo((Expression<Action>)(() => AllEntitiesCount()));

		public static readonly MethodInfo AllRealPlayersCountMethod = SymbolExtensions.GetMethodInfo((Expression<Action>)(() => AllRealPlayersCount()));

		public static readonly MethodInfo IsPlayerLocalOrLethalBotOwnerLocalMethod = SymbolExtensions.GetMethodInfo(Expression.Lambda<Action>(Expression.Call(null, (MethodInfo)MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), Expression.New(typeof(PlayerControllerB))), Array.Empty<ParameterExpression>()));

		public static readonly MethodInfo IsPlayerLocalOrLethalBotMethod = SymbolExtensions.GetMethodInfo(Expression.Lambda<Action>(Expression.Call(null, (MethodInfo)MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), Expression.New(typeof(PlayerControllerB))), Array.Empty<ParameterExpression>()));

		public static readonly MethodInfo IsColliderFromLocalOrLethalBotOwnerLocalMethod = SymbolExtensions.GetMethodInfo(Expression.Lambda<Action>(Expression.Call(null, (MethodInfo)MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), Expression.New(typeof(Collider))), Array.Empty<ParameterExpression>()));

		public static readonly MethodInfo IsPlayerLethalBotMethod = SymbolExtensions.GetMethodInfo(Expression.Lambda<Action>(Expression.Call(null, (MethodInfo)MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), Expression.New(typeof(PlayerControllerB))), Array.Empty<ParameterExpression>()));

		public static readonly MethodInfo IsPlayerLocalMethod = SymbolExtensions.GetMethodInfo(Expression.Lambda<Action>(Expression.Call(null, (MethodInfo)MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), Expression.New(typeof(PlayerControllerB))), Array.Empty<ParameterExpression>()));

		public static readonly MethodInfo IsIdPlayerLethalBotMethod = SymbolExtensions.GetMethodInfo((Expression<Action>)(() => IsIdPlayerLethalBot(0)));

		public static readonly MethodInfo IsRagdollPlayerIdLethalBotMethod = SymbolExtensions.GetMethodInfo(Expression.Lambda<Action>(Expression.Call(null, (MethodInfo)MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), Expression.New(typeof(RagdollGrabbableObject))), Array.Empty<ParameterExpression>()));

		public static readonly MethodInfo IsPlayerLethalBotOwnerLocalMethod = SymbolExtensions.GetMethodInfo(Expression.Lambda<Action>(Expression.Call(null, (MethodInfo)MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), Expression.New(typeof(PlayerControllerB))), Array.Empty<ParameterExpression>()));

		public static readonly MethodInfo IsAnLethalBotAiOwnerOfObjectMethod = SymbolExtensions.GetMethodInfo((Expression<Action>)(() => IsAnLethalBotAiOwnerOfObject((GrabbableObject)new object())));

		public static readonly MethodInfo DisableOriginalGameDebugLogsMethod = SymbolExtensions.GetMethodInfo((Expression<Action>)(() => DisableOriginalGameDebugLogs()));

		public static readonly MethodInfo IsPlayerLethalBotControlledAndOwnerMethod = SymbolExtensions.GetMethodInfo(Expression.Lambda<Action>(Expression.Call(null, (MethodInfo)MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), Expression.New(typeof(PlayerControllerB))), Array.Empty<ParameterExpression>()));

		public static readonly MethodInfo GetDamageFromSlimeIfLethalBotMethod = SymbolExtensions.GetMethodInfo(Expression.Lambda<Action>(Expression.Call(null, (MethodInfo)MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), Expression.New(typeof(PlayerControllerB))), Array.Empty<ParameterExpression>()));

		public static readonly MethodInfo SyncJumpMethod = SymbolExtensions.GetMethodInfo((Expression<Action>)(() => SyncJump(0uL)));

		public static readonly MethodInfo SyncLandFromJumpMethod = SymbolExtensions.GetMethodInfo((Expression<Action>)(() => SyncLandFromJump(0uL, fallHard: false)));

		public static List<CodeInstruction> InsertIsPlayerLethalBotInstructions(List<CodeInstruction> codes, ILGenerator generator, int startIndex, int indexToJumpTo)
		{
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Expected O, but got Unknown
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Expected O, but got Unknown
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Expected O, but got Unknown
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Expected O, but got Unknown
			List<Label> labels = codes[startIndex].labels;
			List<Label> labels2 = codes[startIndex + indexToJumpTo].labels;
			Label label = generator.DefineLabel();
			labels2.Add(label);
			if (labels.Count > 0)
			{
				codes.Insert(startIndex + 1, new CodeInstruction(codes[startIndex].opcode, codes[startIndex].operand));
				codes[startIndex].opcode = OpCodes.Nop;
				codes[startIndex].operand = null;
				startIndex++;
			}
			List<CodeInstruction> collection = new List<CodeInstruction>
			{
				new CodeInstruction(OpCodes.Ldarg_0, (object)null),
				new CodeInstruction(OpCodes.Call, (object)IsPlayerLethalBotMethod),
				new CodeInstruction(OpCodes.Brtrue_S, (object)label)
			};
			codes.InsertRange(startIndex, collection);
			return codes;
		}

		public static List<CodeInstruction> InsertLogOfFieldOfThis(string logWithZeroParameter, FieldInfo fieldInfo, Type fieldType)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Expected O, but got Unknown
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Expected O, but got Unknown
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Expected O, but got Unknown
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Expected O, but got Unknown
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Expected O, but got Unknown
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Expected O, but got Unknown
			//IL_0152: Unknown result type (might be due to invalid IL or missing references)
			//IL_015c: Expected O, but got Unknown
			List<CodeInstruction> list = new List<CodeInstruction>();
			list.Add(new CodeInstruction(OpCodes.Ldsfld, (object)AccessTools.Field(typeof(Plugin), "Logger")));
			list.Add(new CodeInstruction(OpCodes.Ldstr, (object)logWithZeroParameter));
			list.Add(new CodeInstruction(OpCodes.Ldarg_0, (object)null));
			list.Add(new CodeInstruction(OpCodes.Ldfld, (object)fieldInfo));
			list.Add(new CodeInstruction(OpCodes.Box, (object)fieldType));
			list.Add(new CodeInstruction(OpCodes.Call, (object)SymbolExtensions.GetMethodInfo((Expression<Action>)(() => string.Format(new string(new char[0]), new object())))));
			list.Add(new CodeInstruction(OpCodes.Callvirt, (object)SymbolExtensions.GetMethodInfo((Expression<Action>)(() => Plugin.LogDebug(new string(new char[0]))))));
			return list;
		}

		public static List<CodeInstruction> InsertLogWithoutParameters(string log)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Expected O, but got Unknown
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Expected O, but got Unknown
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Expected O, but got Unknown
			List<CodeInstruction> list = new List<CodeInstruction>();
			list.Add(new CodeInstruction(OpCodes.Ldsfld, (object)AccessTools.Field(typeof(Plugin), "Logger")));
			list.Add(new CodeInstruction(OpCodes.Ldstr, (object)log));
			list.Add(new CodeInstruction(OpCodes.Callvirt, (object)SymbolExtensions.GetMethodInfo((Expression<Action>)(() => Plugin.LogDebug(new string(new char[0]))))));
			return list;
		}

		public static List<CodeInstruction> InsertIsBypass(List<CodeInstruction> codes, ILGenerator generator, int startIndex, int indexToJumpTo)
		{
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Expected O, but got Unknown
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Expected O, but got Unknown
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Expected O, but got Unknown
			List<Label> labels = codes[startIndex].labels;
			List<Label> labels2 = codes[startIndex + indexToJumpTo].labels;
			Label label = generator.DefineLabel();
			labels2.Add(label);
			if (labels.Count > 0)
			{
				codes.Insert(startIndex + 1, new CodeInstruction(codes[startIndex].opcode, codes[startIndex].operand));
				codes[startIndex].opcode = OpCodes.Nop;
				codes[startIndex].operand = null;
				startIndex++;
			}
			List<CodeInstruction> collection = new List<CodeInstruction>
			{
				new CodeInstruction(OpCodes.Call, (object)DisableOriginalGameDebugLogsMethod),
				new CodeInstruction(OpCodes.Brtrue_S, (object)label)
			};
			codes.InsertRange(startIndex, collection);
			return codes;
		}

		public static bool IsGrabbableObjectEqualsToNull(GrabbableObject grabbableObject)
		{
			return (Object)(object)grabbableObject == (Object)null;
		}

		private static bool DisableOriginalGameDebugLogs()
		{
			return false;
		}

		private static bool IsPlayerLocal(PlayerControllerB player)
		{
			return LethalBotManager.IsPlayerLocal(player);
		}

		private static bool IsPlayerLocalOrLethalBot(PlayerControllerB player)
		{
			return LethalBotManager.Instance.IsPlayerLocalOrLethalBot(player);
		}

		private static bool IsPlayerLocalOrLethalBotOwnerLocal(PlayerControllerB player)
		{
			return LethalBotManager.Instance.IsPlayerLocalOrLethalBotOwnerLocal(player);
		}

		private static int AllEntitiesCount()
		{
			return LethalBotManager.Instance.AllEntitiesCount;
		}

		private static int AllRealPlayersCount()
		{
			return Math.Clamp(LethalBotManager.Instance.AllRealPlayersCount - 1, 0, AllEntitiesCount());
		}

		private static bool IsColliderFromLocalOrLethalBotOwnerLocal(Collider collider)
		{
			return LethalBotManager.Instance.IsColliderFromLocalOrLethalBotOwnerLocal(collider);
		}

		private static bool IsPlayerLethalBot(PlayerControllerB player)
		{
			return LethalBotManager.Instance.IsPlayerLethalBot(player);
		}

		private static bool IsIdPlayerLethalBot(int id)
		{
			return LethalBotManager.Instance.IsPlayerLethalBot(id);
		}

		private static bool IsRagdollPlayerIdLethalBot(RagdollGrabbableObject ragdollGrabbableObject)
		{
			return LethalBotManager.Instance.IsPlayerLethalBot((int)ragdollGrabbableObject.ragdoll.playerScript.playerClientId);
		}

		private static bool IsPlayerLethalBotOwnerLocal(PlayerControllerB player)
		{
			return LethalBotManager.Instance.IsPlayerLethalBotOwnerLocal(player);
		}

		private static bool IsPlayerLethalBotControlledAndOwner(PlayerControllerB player)
		{
			return LethalBotManager.Instance.IsPlayerLethalBotControlledAndOwner(player);
		}

		private static int GetDamageFromSlimeIfLethalBot(PlayerControllerB player)
		{
			return LethalBotManager.Instance.GetDamageFromSlimeIfLethalBot(player);
		}

		private static bool IsAnLethalBotAiOwnerOfObject(GrabbableObject grabbableObject)
		{
			return LethalBotManager.Instance.IsAnLethalBotAiOwnerOfObject(grabbableObject);
		}

		private static void SyncJump(ulong playerClientId)
		{
			LethalBotManager.Instance.GetLethalBotAI((int)playerClientId)?.SyncJump();
		}

		private static void SyncLandFromJump(ulong playerClientId, bool fallHard)
		{
			LethalBotManager.Instance.GetLethalBotAI((int)playerClientId)?.SyncLandFromJump(fallHard);
		}
	}
	internal static class PropertiesAndFieldsUtils
	{
		public static void ListNamesOfObjectsArray<T>(T[] array)
		{
			Type typeFromHandle = typeof(T);
			Plugin.LogDebug(" ");
			if (array == null)
			{
				Plugin.LogDebug($"Array of type {typeFromHandle} is null");
				return;
			}
			if (array.Length == 0)
			{
				Plugin.LogDebug($"Array of type {typeFromHandle} is empty");
				return;
			}
			PropertyInfo[] readablePropertiesOf = GetReadablePropertiesOf(typeFromHandle);
			Plugin.LogDebug($"- List of type : {typeFromHandle}");
			for (int i = 0; i < array.Length; i++)
			{
				T val = array[i];
				if (val != null)
				{
					Plugin.LogDebug($" Object {i}: \"{NameOfObject(val, readablePropertiesOf)}\"");
				}
			}
		}

		public static void ListPropertiesAndFieldsOfArray<T>(T[] array, bool hasToListProperties = true, bool hasToListFields = true)
		{
			Type typeFromHandle = typeof(T);
			if (array == null)
			{
				Plugin.LogDebug($"Array of type {typeFromHandle} is null");
				return;
			}
			if (array.Length == 0)
			{
				Plugin.LogDebug($"Array of type {typeFromHandle} is empty");
				return;
			}
			PropertyInfo[] readablePropertiesOf = GetReadablePropertiesOf(typeFromHandle);
			FieldInfo[] allFields = GetAllFields(typeFromHandle);
			for (int i = 0; i < array.Length; i++)
			{
				if (hasToListProperties)
				{
					LogProperties(array[i], typeFromHandle, readablePropertiesOf);
				}
				Plugin.LogDebug(" ");
				Plugin.LogDebug($"- Fields of \"{NameOfObject(array[i], readablePropertiesOf)}\" of type \"{typeFromHandle}\" :");
				if (hasToListFields)
				{
					LogFields(array[i], typeFromHandle, allFields);
				}
			}
		}

		public static void ListPropertiesAndFields<T>(T obj, bool hasToListProperties = true, bool hasToListFields = true)
		{
			Type typeFromHandle = typeof(T);
			PropertyInfo[] readablePropertiesOf = GetReadablePropertiesOf(typeFromHandle);
			if (hasToListProperties)
			{
				LogProperties(obj, typeFromHandle, readablePropertiesOf);
			}
			Plugin.LogDebug(" ");
			Plugin.LogDebug($"- Fields of \"{NameOfObject(obj, readablePropertiesOf)}\" of type \"{typeFromHandle}\" :");
			FieldInfo[] allFields = GetAllFields(typeFromHandle);
			if (hasToListFields)
			{
				LogFields(obj, typeFromHandle, allFields);
			}
		}

		public static NetworkObject? GetNetworkObjectByHash(uint hashID)
		{
			FieldInfo field = typeof(NetworkObject).GetField("GlobalObjectIdHash", BindingFlags.Instance | BindingFlags.NonPublic);
			if (field == null)
			{
				Plugin.LogError("GlobalObjectIdHash field is null.");
				return null;
			}
			NetworkObject[] array = Resources.FindObjectsOfTypeAll<NetworkObject>();
			foreach (NetworkObject val in array)
			{
				uint num = (uint)field.GetValue(val);
				if (num == hashID)
				{
					return val;
				}
			}
			return null;
		}

		private static void LogProperties<T>(T obj, Type typeObj, PropertyInfo[] arrObjProperties)
		{
			if (obj == null)
			{
				Plugin.LogDebug($"Object of type {typeObj} is null");
				return;
			}
			Plugin.LogDebug(" ");
			Plugin.LogDebug($"- Properties of \"{NameOfObject(obj, arrObjProperties)}\" of type \"{typeObj}\" :");
			foreach (PropertyInfo propertyInfo in arrObjProperties)
			{
				Plugin.LogDebug($" {propertyInfo.Name} = {GetValueOfProperty(obj, propertyInfo)}");
			}
		}

		private static string NameOfObject<T>(T obj, PropertyInfo[] propertyInfos)
		{
			object valueOfProperty = GetValueOfProperty(obj, propertyInfos.FirstOrDefault((PropertyInfo x) => x.Name == "name"));
			if (valueOfProperty != null)
			{
				return valueOfProperty.ToString();
			}
			return "name null";
		}

		private static void LogFields<T>(T obj, Type typeObj, FieldInfo[] arrObjFields)
		{
			if (obj == null)
			{
				Plugin.LogDebug($"Object of type {typeObj} is null");
				return;
			}
			Plugin.LogDebug(" ");
			foreach (FieldInfo fieldInfo in arrObjFields)
			{
				Plugin.LogDebug($" {fieldInfo.Name} = {GetValueOfField(obj, fieldInfo)}");
			}
		}

		public static FieldInfo[] GetAllFields(Type t)
		{
			if (t == null)
			{
				return new FieldInfo[0];
			}
			BindingFlags bindingAttr = BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic;
			return t.GetFields(bindingAttr).Concat(GetAllFields(t.BaseType)).ToArray();
		}

		private static PropertyInfo[] GetReadablePropertiesOf(Type type)
		{
			return (from x in type.GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.FlattenHierarchy)
				where x.CanRead
				select x).ToArray();
		}

		private static object? GetValueOfProperty<T>(T obj, PropertyInfo propertyInfo)
		{
			if (propertyInfo == null)
			{
				return null;
			}
			if (!propertyInfo.GetAccessors(nonPublic: true)[0].IsStatic)
			{
				return propertyInfo.GetValue(obj, null);
			}
			return propertyInfo.GetValue(null);
		}

		private static object? GetValueOfField<T>(T obj, FieldInfo fieldInfo)
		{
			if (fieldInfo == null)
			{
				return null;
			}
			if (!fieldInfo.IsStatic)
			{
				return fieldInfo.GetValue(obj);
			}
			return fieldInfo.GetValue(null);
		}
	}
	public class RayUtil
	{
		public static void RayCastAndDrawFromPointWithColor(LineRenderer? lr, Vector3 origin, Vector3 endPoint, Color color)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0004: 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_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: 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)
			Ray ray = default(Ray);
			((Ray)(ref ray))..ctor(origin, endPoint - origin);
			float length = Vector3.Distance(endPoint, origin);
			DrawUtil.DrawLine(lr, ray, length, color);
		}

		public static bool RayCastAndDraw(LineRenderer? lr, Vector3 origin, Vector3 directionOrigin, float angle, float length)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: 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_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = Vector3.Cross(directionOrigin, Vector3.up);
			if (val == Vector3.zero)
			{
				val = Vector3.right;
			}
			Ray val2 = default(Ray);
			((Ray)(ref val2))..ctor(origin, Quaternion.AngleAxis(angle, val) * directionOrigin);
			if (Physics.Raycast(val2, length, StartOfRound.Instance.walkableSurfacesMask, (QueryTriggerInteraction)1))
			{
				DrawUtil.DrawLine(lr, val2, length, Color.red);
				return true;
			}
			DrawUtil.DrawWhiteLine(lr, val2, length);
			return false;
		}

		public static bool RayCastForwardAndDraw(LineRenderer? lr, Vector3 origin, Vector3 directionForward, float length)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: 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_0020: Unknown result type (might be due to invalid IL or missing references)
			Ray val = default(Ray);
			((Ray)(ref val))..ctor(origin, directionForward);
			if (Physics.Raycast(val, length, StartOfRound.Instance.walkableSurfacesMask, (QueryTriggerInteraction)1))
			{
				DrawUtil.DrawLine(lr, val, length, Color.red);
				return true;
			}
			DrawUtil.DrawWhiteLine(lr, val, length);
			return false;
		}

		public static bool RayCastDownAndDraw(LineRenderer? lr, Vector3 origin, float length)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: 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_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			Ray val = default(Ray);
			((Ray)(ref val))..ctor(origin, Vector3.down);
			if (Physics.Raycast(val, length, StartOfRound.Instance.walkableSurfacesMask, (QueryTriggerInteraction)1))
			{
				DrawUtil.DrawLine(lr, val, length, Color.red);
				return true;
			}
			DrawUtil.DrawWhiteLine(lr, val, length);
			return false;
		}
	}
	internal static class TreesUtils
	{
		public static void PrintTransformTree(Transform[] tree, string? parent = null)
		{
			if (tree == null)
			{
				Plugin.LogDebug("Tree of transform is null");
				return;
			}
			if (tree.Length == 0)
			{
				Plugin.LogDebug("Tree of transform is empty");
				return;
			}
			if (Utility.IsNullOrWhiteSpace(parent))
			{
				Transform? obj = tree.FirstOrDefault();
				object obj2;
				if (obj == null)
				{
					obj2 = null;
				}
				else
				{
					Transform parent2 = obj.parent;
					if (parent2 == null)
					{
						obj2 = null;
					}
					else
					{
						Transform root = parent2.root;
						obj2 = ((root != null) ? ((Object)root).name : null);
					}
				}
				parent = (string?)obj2;
			}
			TransformTreeTraversal(tree, parent, 0);
		}

		private static void TransformTreeTraversal(Transform[] tree, string? parent, int depth)
		{
			StringBuilder stringBuilder = new StringBuilder();
			foreach (Transform val in tree)
			{
				if ((string.IsNullOrWhiteSpace(parent) && ((Object)(object)val.parent == (Object)null || string.IsNullOrWhiteSpace(((Object)val.parent).name))) || ((Object)(object)val.parent != (Object)null && ((Object)val.parent).name == parent))
				{
					for (int j = 1; j <= depth - 1; j++)
					{
						stringBuilder.Append("│   ");
					}
					if (depth > 0)
					{
						stringBuilder.Append("├──");
					}
					Plugin.LogDebug(stringBuilder.ToString() + ((Object)val).name);
					stringBuilder.Clear();
					TransformTreeTraversal(tree, ((Object)val).name, depth + 1);
				}
			}
		}

		public static void PrintComponentsTreeOfGameObject(GameObject gameObject)
		{
			if ((Object)(object)gameObject == (Object)null)
			{
				Plugin.LogDebug("GameObject is null");
				return;
			}
			Component[] array = (from x in gameObject.GetComponentsInChildren(typeof(Component))
				where (Object)(object)x != (Object)null
				select x).ToArray();
			if (array.Length == 0)
			{
				Plugin.LogDebug("GameObject has no components");
			}
			else
			{
				ComponentTreeTraversal(array);
			}
		}

		private static int ComponentTreeTraversal(Component[] tree, string? parent = null, int index = 0, int depth = 0, string lastTransformName = "")
		{
			StringBuilder stringBuilder = new StringBuilder();
			for (int i = index; i < tree.Length; i++)
			{
				Component val = tree[i];
				Transform val2 = (Transform)(object)((val is Transform) ? val : null);
				bool flag = (Object)(object)val2 != (Object)null;
				if ((Object)(object)val2 == (Object)null)
				{
					val2 = val.transform;
				}
				if (string.IsNullOrWhiteSpace(parent))
				{
					Transform parent2 = val2.parent;
					if (string.IsNullOrWhiteSpace((parent2 != null) ? ((Object)parent2).name : null))
					{
						Plugin.LogDebug((flag ? ((Object)val2).name : ((object)val).ToString()) ?? "");
					}
				}
				if (string.IsNullOrWhiteSpace(parent))
				{
					Transform parent3 = val2.parent;
					if (!string.IsNullOrWhiteSpace((parent3 != null) ? ((Object)parent3).name : null))
					{
						parent = ((Object)val2.parent).name;
					}
				}
				if (parent == ((Object)val2).name)
				{
					for (int j = 1; j <= depth - 1; j++)
					{
						stringBuilder.Append("│   ");
					}
					if (depth > 0)
					{
						stringBuilder.Append("├──");
					}
					Plugin.LogDebug($"{stringBuilder}{(flag ? ((Object)val2).name : ((object)val).ToString())}");
					stringBuilder.Clear();
					continue;
				}
				Transform parent4 = val2.parent;
				if (((parent4 != null) ? ((Object)parent4).name : null) == parent && flag)
				{
					for (int k = 1; k <= depth - 1; k++)
					{
						stringBuilder.Append("│   ");
					}
					if (depth > 0)
					{
						stringBuilder.Append("├──");
					}
					if (!(((Object)val2).name == lastTransformName))
					{
						lastTransformName = ((Object)val2).name;
						Plugin.LogDebug($"{stringBuilder}{((Object)val2).name}");
						stringBuilder.Clear();
						i = ComponentTreeTraversal(tree, ((Object)val2).name, i + 1, depth + 1, lastTransformName);
						index = i;
					}
				}
			}
			return index;
		}
	}
}
namespace LethalBots.Utils.Helpers
{
	public class ChatCommand
	{
		public string Keyword;

		public Func<AIState, LethalBotAI, PlayerControllerB, string, bool, bool> Execute;

		public ChatCommand(string keyword, Func<AIState, LethalBotAI, PlayerControllerB, string, bool, bool> execute)
		{
			Keyword = keyword.ToLower();
			Execute = execute;
		}
	}
	[Serializable]
	public class CountdownTimer : INetworkSerializable, IEquatable<CountdownTimer>
	{
		public float startTime = -1f;

		public float endTime = -1f;

		public void Reset()
		{
			startTime = -1f;
			endTime = -1f;
		}

		public void Start(float time)
		{
			startTime = Time.realtimeSinceStartup;
			endTime = Time.realtimeSinceStartup + ((time >= 0f) ? time : 0f);
		}

		public bool HasStarted()
		{
			return endTime > 0f;
		}

		public float GetElapsedTime()
		{
			if (!HasStarted())
			{
				return -1f;
			}
			return Time.realtimeSinceStartup - startTime;
		}

		public bool Elapsed()
		{
			if (HasStarted())
			{
				return endTime <= Time.realtimeSinceStartup;
			}
			return false;
		}

		public CountdownTimer Clone()
		{
			return new CountdownTimer
			{
				startTime = startTime,
				endTime = endTime
			};
		}

		public unsafe void NetworkSerialize<T>(BufferSerializer<T> serializer) where T : IReaderWriter
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: 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)
			((BufferSerializer<float>*)(&serializer))->SerializeValue<float>(ref startTime, default(ForPrimitives));
			((BufferSerializer<float>*)(&serializer))->SerializeValue<float>(ref endTime, default(ForPrimitives));
		}

		public bool Equals(CountdownTimer other)
		{
			if (startTime == other.startTime)
			{
				return endTime == other.endTime;
			}
			return false;
		}

		public override bool Equals(object? obj)
		{
			if (obj is CountdownTimer other)
			{
				return Equals(other);
			}
			return false;
		}

		public override int GetHashCode()
		{
			return HashCode.Combine(startTime, endTime);
		}

		public static bool operator ==(CountdownTimer? left, CountdownTimer? right)
		{
			if ((object)left == right)
			{
				return true;
			}
			if ((object)left == null || (object)right == null)
			{
				return false;
			}
			return left.Equals(right);
		}

		public static bool operator !=(CountdownTimer? left, CountdownTimer? right)
		{
			return !(left == right);
		}
	}
	public class DunGenTileTracker : MonoBehaviour
	{
		[CompilerGenerated]
		private sealed class <GetAllDoorsInDungeon>d__38 : IEnumerable<Door>, IEnumerable, IEnumerator<Door>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private Door <>2__current;

			private int <>l__initialThreadId;

			private Dungeon dungeon;

			public Dungeon <>3__dungeon;

			private IEnumerator<GameObject> <>7__wrap1;

			Door IEnumerator<Door>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <GetAllDoorsInDungeon>d__38(int <>1__state)
			{
				this.<>1__state = <>1__state;
				<>l__initialThreadId = Environment.CurrentManagedThreadId;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 1)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<>7__wrap1 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<>7__wrap1 = dungeon.Doors.GetEnumerator();
						<>1__state = -3;
						break;
					case 1:
						<>1__state = -3;
						break;
					}
					while (<>7__wrap1.MoveNext())
					{
						GameObject current = <>7__wrap1.Current;
						if ((Object)(object)current != (Object)null)
						{
							Door component = current.GetComponent<Door>();
							if ((Object)(object)component != (Object)null)
							{
								<>2__current = component;
								<>1__state = 1;
								return true;
							}
						}
					}
					<>m__Finally1();
					<>7__wrap1 = null;
					return false;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			private void <>m__Finally1()
			{
				<>1__state = -1;
				if (<>7__wrap1 != null)
				{
					<>7__wrap1.Dispose();
				}
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}

			[DebuggerHidden]
			IEnumerator<Door> IEnumerable<Door>.GetEnumerator()
			{
				<GetAllDoorsInDungeon>d__38 <GetAllDoorsInDungeon>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<GetAllDoorsInDungeon>d__ = this;
				}
				else
				{
					<GetAllDoorsInDungeon>d__ = new <GetAllDoorsInDungeon>d__38(0);
				}
				<GetAllDoorsInDungeon>d__.dungeon = <>3__dungeon;
				return <GetAllDoorsInDungeon>d__;
			}

			[DebuggerHidden]
			IEnumerator IEnumerable.GetEnumerator()
			{
				return ((IEnumerable<Door>)this).GetEnumerator();
			}
		}

		private readonly UpdateLimiter updateLimiter = new UpdateLimiter();

		public int AdjacentTileDepth = 1;

		public bool CullBehindClosedDoors = true;

		public Transform? TargetOverride;

		public bool IncludeDisabledComponents;

		private Tag? disableCullingTag;

		protected List<Dungeon> dungeons = new List<Dungeon>();

		protected List<Tile> allTiles = new List<Tile>();

		protected List<Door> allDoors = new List<Door>();

		protected List<Tile> oldVisibleTiles = new List<Tile>();

		protected List<Tile> visibleTiles = new List<Tile>();

		protected Dictionary<Tile, bool> tileVisibilities = new Dictionary<Tile, bool>();

		private bool dirty;

		private DungeonGenerator generator;

		public Tile? currentTile;

		private Queue<Tile> tilesToSearch;

		private List<Tile> searchedTiles;

		public LethalBotAI lethalBotAI { get; internal set; }

		public Tag DisableCullingTag
		{
			get
			{
				if (disableCullingTag == (Tag)null)
				{
					disableCullingTag = StartOfRound.Instance.occlusionCuller.DisableCullingTag;
				}
				return disableCullingTag;
			}
			set
			{
				disableCullingTag = value;
			}
		}

		public bool Ready { get; protected set; }

		protected Transform targetTransform
		{
			get
			{
				if ((Object)(object)TargetOverride == (Object)null)
				{
					return ((Component)this).transform;
				}
				return TargetOverride;
			}
		}

		protected virtual void OnEnable()
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Expected O, but got Unknown
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Invalid comparison between Unknown and I4
			RuntimeDungeon val = UnityUtil.FindObjectByType<RuntimeDungeon>();
			if ((Object)(object)val != (Object)null)
			{
				generator = val.Generator;
				generator.OnGenerationComplete += new DungeonGenerationDelegate(OnDungeonGenerationComplete);
				if ((int)generator.Status == 8)
				{
					AddDungeon(generator.CurrentDungeon);
				}
			}
		}

		protected virtual void OnDisable()
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Expected O, but got Unknown
			if (generator != null)
			{
				generator.OnGenerationComplete -= new DungeonGenerationDelegate(OnDungeonGenerationComplete);
			}
			for (int i = 0; i < allTiles.Count; i++)
			{
				if ((Object)(object)allTiles[i] != (Object)null)
				{
					SetTileVisibility(allTiles[i], visible: true);
				}
			}
			ClearAllDungeons();
		}

		public virtual void SetDungeon(Dungeon newDungeon)
		{
			if ((Object)(object)newDungeon != (Object)null)
			{
				ClearAllDungeons();
				AddDungeon(newDungeon);
			}
		}

		public virtual void AddDungeon(Dungeon? dungeon)
		{
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Expected O, but got Unknown
			if ((Object)(object)dungeon == (Object)null || dungeons.Contains(dungeon))
			{
				return;
			}
			dungeons.Add(dungeon);
			List<Tile> list = new List<Tile>(dungeon.AllTiles);
			List<Door> list2 = new List<Door>(GetAllDoorsInDungeon(dungeon));
			allTiles.AddRange(list);
			allDoors.AddRange(list2);
			foreach (Tile item in list)
			{
				if (!item.Tags.Tags.Contains(DisableCullingTag))
				{
					SetTileVisibility(item, visible: false);
				}
			}
			foreach (Door item2 in list2)
			{
				item2.OnDoorStateChanged += new DoorStateChangedDelegate(OnDoorStateChanged);
			}
			Ready = true;
			dirty = true;
		}

		private void RemoveNullKeys<TKey, TValue>(ref Dictionary<TKey, TValue> dictionary)
		{
			TKey[] array = dictionary.Keys.Where((TKey val) => val == null).ToArray();
			TKey[] array2 = array;
			foreach (TKey key in array2)
			{
				if (dictionary.ContainsKey(key))
				{
					dictionary.Remove(key);
				}
			}
		}

		public virtual void RemoveDungeon(Dungeon dungeon)
		{
			//IL_0149: Unknown result type (might be due to invalid IL or missing references)
			//IL_0153: Expected O, but got Unknown
			if ((Object)(object)dungeon == (Object)null || !dungeons.Contains(dungeon))
			{
				return;
			}
			dungeons.Remove(dungeon);
			allTiles.RemoveAll((Tile x) => !Object.op_Implicit((Object)(object)x));
			visibleTiles.RemoveAll((Tile x) => !Object.op_Implicit((Object)(object)x));
			allDoors.RemoveAll((Door x) => !Object.op_Implicit((Object)(object)x));
			RemoveNullKeys(ref tileVisibilities);
			foreach (Tile allTile in dungeon.AllTiles)
			{
				SetTileVisibility(allTile, visible: true);
				allTiles.Remove(allTile);
				tileVisibilities.Remove(allTile);
				visibleTiles.Remove(allTile);
				oldVisibleTiles.Remove(allTile);
			}
			Door val = default(Door);
			foreach (GameObject door in dungeon.Doors)
			{
				if ((Object)(object)door != (Object)null && door.TryGetComponent<Door>(ref val))
				{
					val.OnDoorStateChanged -= new DoorStateChangedDelegate(OnDoorStateChanged);
					allDoors.Remove(val);
				}
			}
			if (allTiles.Count == 0)
			{
				Ready = false;
			}
		}

		public virtual void ClearAllDungeons()
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Expected O, but got Unknown
			Ready = false;
			foreach (Door allDoor in allDoors)
			{
				if ((Object)(object)allDoor != (Object)null)
				{
					allDoor.OnDoorStateChanged -= new DoorStateChangedDelegate(OnDoorStateChanged);
				}
			}
			dungeons.Clear();
			allTiles.Clear();
			visibleTiles.Clear();
			allDoors.Clear();
			oldVisibleTiles.Clear();
			tileVisibilities.Clear();
		}

		public virtual bool IsTileVisible(Tile tile)
		{
			if (tileVisibilities.TryGetValue(tile, out var value))
			{
				return value;
			}
			return false;
		}

		[IteratorStateMachine(typeof(<GetAllDoorsInDungeon>d__38))]
		protected IEnumerable<Door> GetAllDoorsInDungeon(Dungeon dungeon)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <GetAllDoorsInDungeon>d__38(-2)
			{
				<>3__dungeon = dungeon
			};
		}

		protected virtual void OnDoorStateChanged(Door door, bool isOpen)
		{
			dirty = true;
		}

		protected virtual void OnDungeonGenerationComplete(DungeonGenerator generator)
		{
			if ((generator.AttachmentSettings == null || generator.AttachmentSettings.TileProxy == null) && dungeons.Count > 0)
			{
				RemoveDungeon(dungeons[dungeons.Count - 1]);
			}
			AddDungeon(generator.CurrentDungeon);
		}

		protected virtual void LateUpdate()
		{
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			if (!Ready || !updateLimiter.CanUpdate())
			{
				return;
			}
			updateLimiter.SetUpdateInterval(((EnemyAI)lethalBotAI).AIIntervalTime);
			updateLimiter.Invalidate();
			if (!lethalBotAI.NpcController.Npc.isInsideFactory)
			{
				return;
			}
			Tile val = currentTile;
			if ((Object)(object)currentTile == (Object)null)
			{
				currentTile = FindCurrentTile();
			}
			else
			{
				Bounds bounds = currentTile.Bounds;
				if (!((Bounds)(ref bounds)).Contains(targetTransform.position))
				{
					currentTile = SearchForNewCurrentTile();
				}
			}
			if ((Object)(object)currentTile != (Object)(object)val && (Object)(object)currentTile != (Object)null)
			{
				dirty = true;
			}
			if (dirty)
			{
				RefreshVisibility();
			}
			dirty = false;
		}

		public Tile? GetStartTile()
		{
			for (int i = 0; i < allTiles.Count; i++)
			{
				if (allTiles[i].Placement.NormalizedPathDepth == 0f)
				{
					return allTiles[i];
				}
			}
			return null;
		}

		public void SetToStartTile()
		{
			if (!Ready)
			{
				return;
			}
			Tile val = currentTile;
			if ((Object)(object)RoundManager.Instance.dungeonGenerator == (Object)null)
			{
				Plugin.LogError("RoundManager dungeon generator is null! Cannot set StartTile as current tile!");
				return;
			}
			Tile val2 = RoundManager.Instance.dungeonGenerator.Generator.CurrentDungeon.MainPathTiles[0];
			for (int i = 0; i < allTiles.Count; i++)
			{
				if ((Object)(object)allTiles[i] == (Object)(object)val2)
				{
					Plugin.LogInfo("DunGenTileTracker: Got start tile!");
					currentTile = allTiles[i];
					break;
				}
			}
			if ((Object)(object)currentTile != (Object)(object)val && (Object)(object)currentTile != (Object)null)
			{
				dirty = true;
			}
			if (dirty)
			{
				RefreshVisibility();
			}
			dirty = false;
		}

		protected virtual void RefreshVisibility()
		{
			List<Tile> list = visibleTiles;
			visibleTiles = oldVisibleTiles;
			oldVisibleTiles = list;
			UpdateVisibleTiles();
			foreach (Tile oldVisibleTile in oldVisibleTiles)
			{
				if (!visibleTiles.Contains(oldVisibleTile) && !oldVisibleTile.Tags.Tags.Contains(DisableCullingTag))
				{
					SetTileVisibility(oldVisibleTile, visible: false);
				}
			}
			foreach (Tile visibleTile in visibleTiles)
			{
				if (!oldVisibleTiles.Contains(visibleTile))
				{
					SetTileVisibility(visibleTile, visible: true);
				}
			}
			oldVisibleTiles.Clear();
		}

		protected virtual void UpdateVisibleTiles()
		{
			visibleTiles.Clear();
			if ((Object)(object)currentTile != (Object)null)
			{
				visibleTiles.Add(currentTile);
			}
			int num = 0;
			for (int i = 0; i < AdjacentTileDepth; i++)
			{
				int count = visibleTiles.Count;
				for (int j = num; j < count; j++)
				{
					foreach (Doorway usedDoorway in visibleTiles[j].UsedDoorways)
					{
						Tile tile = usedDoorway.ConnectedDoorway.Tile;
						if ((Object)(object)tile == (Object)null || visibleTiles.Contains(tile))
						{
							continue;
						}
						if (CullBehindClosedDoors)
						{
							Door doorComponent = usedDoorway.DoorComponent;
							if ((Object)(object)doorComponent != (Object)null && doorComponent.ShouldCullBehind)
							{
								continue;
							}
						}
						visibleTiles.Add(tile);
					}
				}
				num = count;
			}
		}

		protected virtual void SetTileVisibility(Tile tile, bool visible)
		{
			tileVisibilities[tile] = visible;
		}

		protected Tile? FindCurrentTile()
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			foreach (Tile allTile in allTiles)
			{
				if ((Object)(object)allTile != (Object)null)
				{
					Bounds bounds = allTile.Bounds;
					if (((Bounds)(ref bounds)).Contains(targetTransform.position))
					{
						return allTile;
					}
				}
			}
			return null;
		}

		protected Tile? SearchForNewCurrentTile()
		{
			//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_002a: 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_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			Bounds bounds;
			if ((Object)(object)RoundManager.Instance.startRoomSpecialBounds != (Object)null)
			{
				bounds = RoundManager.Instance.startRoomSpecialBounds.bounds;
				if (((Bounds)(ref bounds)).Contains(targetTransform.position))
				{
					Tile startTile = GetStartTile();
					if ((Object)(object)startTile != (Object)null)
					{
						return startTile;
					}
				}
			}
			if (tilesToSearch == null)
			{
				tilesToSearch = new Queue<Tile>();
			}
			if (searchedTiles == null)
			{
				searchedTiles = new List<Tile>();
			}
			if ((Object)(object)currentTile == (Object)null)
			{
				return null;
			}
			foreach (Doorway usedDoorway in currentTile.UsedDoorways)
			{
				Tile tile = usedDoorway.ConnectedDoorway.Tile;
				if ((Object)(object)tile != (Object)null && !tilesToSearch.Contains(tile))
				{
					tilesToSearch.Enqueue(tile);
				}
			}
			while (tilesToSearch.Count > 0)
			{
				Tile val = tilesToSearch.Dequeue();
				bounds = val.Bounds;
				if (((Bounds)(ref bounds)).Contains(targetTransform.position))
				{
					tilesToSearch.Clear();
					searchedTiles.Clear();
					return val;
				}
				searchedTiles.Add(val);
				foreach (Doorway usedDoorway2 in val.UsedDoorways)
				{
					Tile tile2 = usedDoorway2.ConnectedDoorway.Tile;
					if ((Object)(object)tile2 != (Object)null && !tilesToSearch.Contains(tile2) && !searchedTiles.Contains(tile2))
					{
						tilesToSearch.Enqueue(tile2);
					}
				}
			}
			searchedTiles.Clear();
			return null;
		}
	}
	[Serializable]
	public class IntervalTimer : INetworkSerializable, IEquatable<IntervalTimer>
	{
		public float timestamp = -1f;

		public void Reset()
		{
			timestamp = Time.realtimeSinceStartup;
		}

		public void Start()
		{
			timestamp = Time.realtimeSinceStartup;
		}

		public void Invalidate()
		{
			timestamp = -1f;
		}

		public bool HasStarted()
		{
			return timestamp > 0f;
		}

		public float GetElapsedTime()
		{
			if (!HasStarted())
			{
				return -1f;
			}
			return Time.realtimeSinceStartup - timestamp;
		}

		public bool IsGreaterThan(float duration)
		{
			return GetElapsedTime() > duration;
		}

		public bool IsLessThan(float duration)
		{
			return GetElapsedTime() < duration;
		}

		public IntervalTimer Clone()
		{
			return new IntervalTimer
			{
				timestamp = timestamp
			};
		}

		public unsafe void NetworkSerialize<T>(BufferSerializer<T> serializer) where T : IReaderWriter
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			((BufferSerializer<float>*)(&serializer))->SerializeValue<float>(ref timestamp, default(ForPrimitives));
		}

		public bool Equals(IntervalTimer other)
		{
			return timestamp == other.timestamp;
		}

		public override bool Equals(object? obj)
		{
			if (obj is IntervalTimer other)
			{
				return Equals(other);
			}
			return false;
		}

		public override int GetHashCode()
		{
			return HashCode.Combine(timestamp);
		}

		public static bool operator ==(IntervalTimer? left, IntervalTimer? right)
		{
			if ((object)left == right)
			{
				return true;
			}
			if ((object)left == null || (object)right == null)
			{
				return false;
			}
			return left.Equals(right);
		}

		public static bool operator !=(IntervalTimer? left, IntervalTimer? right)
		{
			return !(left == right);
		}
	}
	[Serializable]
	public sealed class LethalBotInfection : INetworkSerializable, IEquatable<LethalBotInfection>
	{
		public float showSignsMeter;

		public float timeAtLastHealing;

		public float setPoison;

		public float sprayOnPlayerMeter;

		public float totalTimeSpentInPlants;

		public bool stoodInWeedsLastCheck;

		public float localPlayerImmunityTimer;

		public unsafe void NetworkSerialize<T>(BufferSerializer<T> serializer) where T : IReaderWriter
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: 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_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			((BufferSerializer<float>*)(&serializer))->SerializeValue<float>(ref showSignsMeter, default(ForPrimitives));
			((BufferSerializer<float>*)(&serializer))->SerializeValue<float>(ref timeAtLastHealing, default(ForPrimitives));
			((BufferSerializer<float>*)(&serializer))->SerializeValue<float>(ref setPoison, default(ForPrimitives));
			((BufferSerializer<float>*)(&serializer))->SerializeValue<float>(ref sprayOnPlayerMeter, default(ForPrimitives));
			((BufferSerializer<float>*)(&serializer))->SerializeValue<float>(ref totalTimeSpentInPlants, default(ForPrimitives));
			((BufferSerializer<bool>*)(&serializer))->SerializeValue<bool>(ref stoodInWeedsLastCheck, default(ForPrimitives));
			((BufferSerializer<float>*)(&serializer))->SerializeValue<float>(ref localPlayerImmunityTimer, default(ForPrimitives));
		}

		public bool Equals(LethalBotInfection? other)
		{
			if (other != null && showSignsMeter == other.showSignsMeter && timeAtLastHealing == other.timeAtLastHealing && setPoison == other.setPoison && sprayOnPlayerMeter == other.sprayOnPlayerMeter && totalTimeSpentInPlants == other.totalTimeSpentInPlants && stoodInWeedsLastCheck == other.stoodInWeedsLastCheck)
			{
				return localPlayerImmunityTimer == other.localPlayerImmunityTimer;
			}
			return false;
		}

		public override bool Equals(object obj)
		{
			if (obj is LethalBotInfection other)
			{
				return Equals(other);
			}
			return false;
		}

		public override int GetHashCode()
		{
			return HashCode.Combine(showSignsMeter, timeAtLastHealing, setPoison, sprayOnPlayerMeter, totalTimeSpentInPlants, stoodInWeedsLastCheck, localPlayerImmunityTimer);
		}
	}
	public class LethalBotInteraction
	{
		private InteractTrigger interactTrigger;

		private Action<LethalBotAI, PlayerControllerB, InteractTrigger>? postInteractFunc;

		private bool skipOriginalInteract;

		private bool ignoreHandLimit;

		private bool ignoreInteractablility;

		public bool isBeingHeldByPlayer;

		private float holdFillAmount;

		public bool IsCompleted { get; private set; }

		public LethalBotInteraction(InteractTrigger interactTrigger, bool ignoreInteractablility = false, bool ignoreHandLimit = false)
		{
			this.interactTrigger = interactTrigger;
			this.ignoreHandLimit = ignoreHandLimit;
			this.ignoreInteractablility = ignoreInteractablility;
			skipOriginalInteract = false;
		}

		public LethalBotInteraction(InteractTrigger interactTrigger, Action<LethalBotAI, PlayerControllerB, InteractTrigger> postInteractFunc, bool ignoreInteractablility = false, bool skipOriginalInteract = false, bool ignoreHandLimit = false)
			: this(interactTrigger, ignoreInteractablility, ignoreHandLimit)
		{
			this.postInteractFunc = postInteractFunc;
			this.skipOriginalInteract = skipOriginalInteract;
		}

		public void Update(LethalBotAI lethalBotAI, float deltaTime)
		{
			if (IsCompleted)
			{
				return;
			}
			PlayerControllerB npc = lethalBotAI.NpcController.Npc;
			if ((Object)(object)interactTrigger == (Object)null || (!ignoreInteractablility && !interactTrigger.interactable))
			{
				StopHoldInteractionOnTrigger();
				return;
			}
			if (!((Component)interactTrigger).gameObject.activeInHierarchy || !interactTrigger.holdInteraction || interactTrigger.currentCooldownValue > 0f || (!ignoreHandLimit && npc.isHoldingObject && !interactTrigger.oneHandedItemAllowed) || (!ignoreHandLimit && npc.twoHanded && !interactTrigger.twoHandedItemAllowed))
			{
				StopHoldInteractionOnTrigger();
				return;
			}
			if (!HoldInteractFill(deltaTime, interactTrigger.timeToHold, interactTrigger.timeToHoldSpeedMultiplier))
			{
				HoldInteractNotFilled();
				return;
			}
			IsCompleted = true;
			try
			{
				if (!skipOriginalInteract)
				{
					interactTrigger.Interact(npc.thisPlayerBody);
				}
			}
			catch (Exception arg)
			{
				Plugin.LogError($"LethalBotInteraction had an error when calling interactTrigger.Interact on {interactTrigger}. Error: {arg}");
			}
			try
			{
				postInteractFunc?.Invoke(lethalBotAI, npc, interactTrigger);
			}
			catch (Exception arg2)
			{
				Plugin.LogError($"LethalBotInteraction had an error when calling postInteractFunc. Error: {arg2}");
			}
		}

		private bool HoldInteractFill(float deltaTime, float timeToHold, float speedMultiplier = 1f)
		{
			if (timeToHold == -1f)
			{
				return false;
			}
			holdFillAmount += deltaTime * speedMultiplier;
			if (holdFillAmount > timeToHold)
			{
				holdFillAmount = 0f;
				return true;
			}
			return false;
		}

		private void HoldInteractNotFilled()
		{
			((UnityEvent<float>)(object)interactTrigger.holdingInteractEvent).Invoke(holdFillAmount / interactTrigger.timeToHold);
			if (!interactTrigger.specialCharacterAnimation && !interactTrigger.isLadder)
			{
				if (!interactTrigger.isBeingHeldByPlayer && !isBeingHeldByPlayer)
				{
					((UnityEvent<PlayerControllerB>)(object)interactTrigger.onInteractEarly).Invoke((PlayerControllerB)null);
				}
				isBeingHeldByPlayer = true;
			}
		}

		public void StopHoldInteractionOnTrigger()
		{
			if (!IsCompleted)
			{
				IsCompleted = true;
				holdFillAmount = 0f;
				if ((Object)(object)interactTrigger != (Object)null && isBeingHeldByPlayer && interactTrigger.currentCooldownValue <= 0f)
				{
					isBeingHeldByPlayer = false;
					((UnityEvent<PlayerControllerB>)(object)interactTrigger.onStopInteract).Invoke((PlayerControllerB)null);
				}
			}
		}
	}
	public sealed class Overrideable<T>
	{
		private T _value;

		public bool IsOverridden { get; private set; }

		public T Value
		{
			get
			{
				return _value;
			}
			set
			{
				_value = value;
				IsOverridden = true;
			}
		}

		internal Overrideable(T initialValue)
		{
			_value = initialValue;
			IsOverridden = false;
		}

		public void Apply(T newValue)
		{
			if (!IsOverridden)
			{
				_value = newValue;
			}
			IsOverridden = false;
		}

		public static implicit operator T(Overrideable<T> overrideable)
		{
			return overrideable._value;
		}
	}
	public class PriorityQueue<T>
	{
		private readonly Dictionary<QueuePriority, Queue<T>> _queues;

		public int Count
		{
			get
			{
				int num = 0;
				foreach (Queue<T> value in _queues.Values)
				{
					num += value.Count;
				}
				return num;
			}
		}

		public PriorityQueue()
		{
			_queues = new Dictionary<QueuePriority, Queue<T>>
			{
				{
					QueuePriority.Critical,
					new Queue<T>()
				},
				{
					QueuePriority.High,
					new Queue<T>()
				},
				{
					QueuePriority.Normal,
					new Queue<T>()
				},
				{
					QueuePriority.Low,
					new Queue<T>()
				}
			};
		}

		public void Enqueue(T message, QueuePriority priority = QueuePriority.Low)
		{
			_queues[priority].Enqueue(message);
		}

		public bool TryDequeue(out T? message)
		{
			for (QueuePriority queuePriority = QueuePriority.Critical; queuePriority <= QueuePriority.Low; queuePriority++)
			{
				Queue<T> queue = _queues[queuePriority];
				if (queue.TryDequeue(out message))
				{
					return true;
				}
			}
			message = default(T);
			return false;
		}

		public bool TryPeek(out T? message)
		{
			for (QueuePriority queuePriority = QueuePriority.Critical; queuePriority <= QueuePriority.Low; queuePriority++)
			{
				Queue<T> queue = _queues[queuePriority];
				if (queue.TryPeek(out message))
				{
					return true;
				}
			}
			message = default(T);
			return false;
		}
	}
	public class SignalTranslatorCommand
	{
		public string Keyword;

		public Func<AIState, LethalBotAI, string, bool> Execute;

		public SignalTranslatorCommand(string keyword, Func<AIState, LethalBotAI, string, bool> execute)
		{
			Keyword = keyword.ToLower();
			Execute = execute;
		}
	}
	public class UpdateLimiter
	{
		private static ConditionalWeakTable<EnemyAI, UpdateLimiter> nextUpdateList = new ConditionalWeakTable<EnemyAI, UpdateLimiter>();

		private readonly CountdownTimer nextUpdateTimer = new CountdownTimer();

		private float updateInterval;

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static UpdateLimiter GetOrCreateMonitor(EnemyAI ai, float updateInterval = 0.5f)
		{
			return nextUpdateList.GetValue(ai, (EnemyAI _) => new UpdateLimiter(updateInterval));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static void RemoveMonitor(EnemyAI ai)
		{
			nextUpdateList.Remove(ai);
		}

		internal UpdateLimiter(float updateInterval = 0.5f)
		{
			this.updateInterval = updateInterval;
			Invalidate();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void SetUpdateInterval(float updateInterval)
		{
			this.updateInterval = updateInterval;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public bool CanUpdate()
		{
			if (nextUpdateTimer.HasStarted())
			{
				return nextUpdateTimer.Elapsed();
			}
			return true;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void Invalidate()
		{
			nextUpdateTimer.Start(updateInterval);
		}
	}
}
namespace LethalBots.SaveAdapter
{
	[Serializable]
	public class SaveFile
	{
		public IdentitySaveFile[] IdentitiesSaveFiles;
	}
	[Serializable]
	public class IdentitySaveFile
	{
		public int IdIdentity;

		public int SuitID;

		public int Hp;

		public int Status;

		public int XP;

		public int Level;

		public override string ToString()
		{
			return $"IdIdentity: {IdIdentity}, suitID {SuitID}, Hp {Hp}, XP {XP}, Level {Level}, Status {Status} {(EnumStatusIdentity)Status}";
		}
	}
}
namespace LethalBots.Properties
{
	[GeneratedCode("System.Resources.Tools.StronglyTypedResourceBuilder", "17.0.0.0")]
	[DebuggerNonUserCode]
	[CompilerGenerated]
	public class Resources
	{
		private static ResourceManager resourceMan;

		private static CultureInfo resourceCulture;

		[EditorBrowsable(EditorBrowsableState.Advanced)]
		internal static ResourceManager ResourceManager
		{
			get
			{
				if (resourceMan == null)
				{
					ResourceManager resourceManager = new ResourceManager("LethalBot.Properties.Resources", typeof(Resources).Assembly);
					resourceMan = resourceManager;
				}
				return resourceMan;
			}
		}

		[EditorBrowsable(EditorBrowsableState.Advanced)]
		internal static CultureInfo Culture
		{
			get
			{
				return resourceCulture;
			}
			set
			{
				resourceCulture = value;
			}
		}

		internal Resources()
		{
		}
	}
}
namespace LethalBots.Patches.ObjectsPatches
{
	[HarmonyPatch(typeof(CaveDwellerPhysicsProp))]
	public class CaveDwellerPhysicsPropPatch
	{
		[HarmonyPatch("Start")]
		[HarmonyPostfix]
		private static void Start_Postfix(CaveDwellerPhysicsProp __instance)
		{
			LethalBotManager.Instance.GrabbableObjectSpawned((GrabbableObject)(object)__instance);
		}

		[HarmonyPatch("Update")]
		[HarmonyPrefix]
		private static bool Update_Prefix(CaveDwellerPhysicsProp __instance)
		{
			PlayerControllerB playerHeldBy = ((GrabbableObject)__instance).playerHeldBy;
			CaveDwellerAI caveDwellerScript = __instance.caveDwellerScript;
			if ((Object)(object)caveDwellerScript == (Object)null || (Object)(object)playerHeldBy == (Object)null)
			{
				return true;
			}
			LethalBotAI lethalBotAIIfLocalIsOwner = LethalBotManager.Instance.GetLethalBotAIIfLocalIsOwner(playerHeldBy);
			if (((GrabbableObject)__instance).isHeld && (Object)(object)lethalBotAIIfLocalIsOwner != (Object)null && caveDwellerScript.rockingBaby > 0)
			{
				float value = lethalBotAIIfLocalIsOwner.FearLevel.Value;
				if (caveDwellerScript.rockingBaby < 2 && value > 0.75f)
				{
					caveDwellerScript.rockingBaby = 2;
					playerHeldBy.playerBodyAnimator.SetInteger("RockBaby", 2);
					__instance.SetRockingBabyServerRpc(true);
				}
				else if (value < 0.6f && caveDwellerScript.rockingBaby > 2)
				{
					caveDwellerScript.rockingBaby = 1;
					playerHeldBy.playerBodyAnimator.SetInteger("RockBaby", 1);
					__instance.SetRockingBabyServerRpc(false);
				}
			}
			return true;
		}

		[HarmonyPatch("DropBabyClientRpc")]
		[HarmonyPrefix]
		private static bool DropBabyClientRpc_Prefix(CaveDwellerAI __instance, int playerId)
		{
			LethalBotAI lethalBotAIIfLocalIsOwner = LethalBotManager.Instance.GetLethalBotAIIfLocalIsOwner(playerId);
			if ((Object)(object)lethalBotAIIfLocalIsOwner != (Object)null)
			{
				return false;
			}
			return true;
		}

		[HarmonyPatch("DiscardItem")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> DiscardItem_Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator generator)
		{
			//IL_0131: Unknown result type (might be due to invalid IL or missing references)
			//IL_013b: Expected O, but got Unknown
			//IL_0143: Unknown result type (might be due to invalid IL or missing references)
			//IL_014d: Expected O, but got Unknown
			//IL_0155: Unknown result type (might be due to invalid IL or missing references)
			//IL_015f: Expected O, but got Unknown
			//IL_022a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0234: Expected O, but got Unknown
			//IL_023c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0246: Expected O, but got Unknown
			//IL_024e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0258: Expected O, but got Unknown
			int num = -1;
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			MethodInfo methodInfo = AccessTools.PropertyGetter(typeof(GameNetworkManager), "Instance");
			FieldInfo fieldInfo = AccessTools.Field(typeof(GameNetworkManager), "localPlayerController");
			FieldInfo fieldInfo2 = AccessTools.Field(typeof(GrabbableObject), "playerHeldBy");
			FieldInfo fieldInfo3 = AccessTools.Field(typeof(PlayerControllerB), "playerBodyAnimator");
			FieldInfo fieldInfo4 = AccessTools.Field(typeof(PlayerControllerB), "playerClientId");
			Plugin.LogDebug("Beginning to patch CaveDwellerPhysicsProp.DiscardItem!");
			for (int i = 0; i < list.Count - 2; i++)
			{
				if (CodeInstructionExtensions.Calls(list[i], methodInfo) && CodeInstructionExtensions.LoadsField(list[i + 1], fieldInfo, false) && CodeInstructionExtensions.LoadsField(list[i + 2], fieldInfo3, false))
				{
					Plugin.LogDebug($"Patching localPlayerController usage at index {i}...");
					Plugin.LogDebug($"Original Codes: 1: {list[i]}, 2: {list[i + 1]}, 3: {list[i + 2]}");