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;
using Dissonance.Integrations.Unity_NFGO;
using DunGen;
using DunGen.Tags;
using FacilityMeltdown.API;
using GameNetcodeStuff;
using GeneralImprovements;
using HarmonyLib;
using LCAutoRevive;
using LCAutoRevive.Utils;
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.AutoRevive;
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.Collections;
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("7.1.0.0")]
[assembly: AssemblyInformationalVersion("7.1.0+dc64c8d37cfeea2a4824bb937dfd1becbe511cd2")]
[assembly: AssemblyProduct("LethalBots")]
[assembly: AssemblyTitle("LethalBots")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("7.1.0.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", "7.1.0")]
	[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.*/)]
	[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;

		internal static bool IsModAutoReviveLoaded;

		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(typeof(Plugin).Assembly.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_0223: Unknown result type (might be due to invalid IL or missing references)
			//IL_0231: Expected O, but got Unknown
			//IL_0260: Unknown result type (might be due to invalid IL or missing references)
			//IL_026c: Expected O, but got Unknown
			//IL_029b: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a7: Expected O, but got Unknown
			//IL_03b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_03bd: Expected O, but got Unknown
			//IL_03ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_03fb: Expected O, but got Unknown
			//IL_0467: Unknown result type (might be due to invalid IL or missing references)
			//IL_0475: Expected O, but got Unknown
			//IL_04a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_04b6: Expected O, but got Unknown
			//IL_04e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_04f1: Expected O, but got Unknown
			//IL_051e: Unknown result type (might be due to invalid IL or missing references)
			//IL_052c: Expected O, but got Unknown
			//IL_0559: Unknown result type (might be due to invalid IL or missing references)
			//IL_0567: Expected O, but got Unknown
			//IL_0594: Unknown result type (might be due to invalid IL or missing references)
			//IL_05a2: Expected O, but got Unknown
			//IL_05ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_05fd: Expected O, but got Unknown
			//IL_062a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0638: Expected O, but got Unknown
			//IL_0665: Unknown result type (might be due to invalid IL or missing references)
			//IL_0673: Expected O, but got Unknown
			//IL_06a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_06ae: Expected O, but got Unknown
			//IL_0732: Unknown result type (might be due to invalid IL or missing references)
			//IL_0740: Expected O, but got Unknown
			//IL_076e: Unknown result type (might be due to invalid IL or missing references)
			//IL_077b: Expected O, but got Unknown
			//IL_07a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_07b6: Expected O, but got Unknown
			//IL_07e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_07f1: 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");
			IsModAutoReviveLoaded = IsModLoaded("Tomatobird.AutoRevive");
			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));
			}
			if (IsModAutoReviveLoaded)
			{
				_harmony.PatchAll(typeof(AutoRevivePlayerPatch));
				_harmony.Patch((MethodBase)AccessTools.Method(AccessTools.TypeByName("LCAutoRevive.Patches.PlayerControllerBPatcher"), "KillPlayerPostfix", (Type[])null, (Type[])null), new HarmonyMethod(typeof(LethalBotAutoReviveHelper), "KillPlayerPostfix_Prefix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				_harmony.Patch((MethodBase)AccessTools.Method(AccessTools.TypeByName("LCAutoRevive.Patches.StartOfRoundPatcher"), "ReviveDeadPlayersPostfix", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(typeof(LethalBotAutoReviveHelper), "ReviveDeadPlayersPostfix_Postfix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				_harmony.Patch((MethodBase)AccessTools.Method(AccessTools.TypeByName("LCAutoRevive.Patches.StartOfRoundPatcher"), "ShipLeavePostfix", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(typeof(LethalBotAutoReviveHelper), "ShipLeavePostfix_Postfix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				_harmony.Patch((MethodBase)AccessTools.Method(AccessTools.TypeByName("LCAutoRevive.Network.NetworkHandler"), "CheckIfAllPlayersDead", (Type[])null, (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(typeof(LethalBotAutoReviveHelper), "CheckIfAllPlayersDead_Transpiler", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null);
			}
		}

		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 = "7.1.0";
	}
}
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 FieldRef<PumaAI, bool> stalkingFrozenField = (FieldRef<PumaAI, bool>)(object)AccessTools.FieldRefAccess<bool>(typeof(PumaAI), "stalkingFrozen");

		public static readonly FieldRef<SpringManAI, float> stopMovementTimerField = (FieldRef<SpringManAI, float>)(object)AccessTools.FieldRefAccess<float>(typeof(SpringManAI), "stopMovementTimer");

		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[] Keywords;

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

		public ChatCommand(string keyword, Func<AIState, LethalBotAI, PlayerControllerB, string, bool, bool> execute)
		{
			Keywords = new string[1] { keyword.ToLower() };
			Execute = execute;
		}

		public ChatCommand(string[] keywords, Func<AIState, LethalBotAI, PlayerControllerB, string, bool, bool> execute)
		{
			for (int i = 0; i < keywords.Length; i++)
			{
				keywords[i] = keywords[i].ToLower();
			}
			Keywords = keywords;
			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 static bool operator ==(LethalBotInfection? left, LethalBotInfection? right)
		{
			if ((object)left == right)
			{
				return true;
			}
			if ((object)left == null || (object)right == null)
			{
				return false;
			}
			return left.Equals(right);
		}

		public static bool operator !=(LethalBotInfection? left, LethalBotInfection? right)
		{
			return !(left == right);
		}
	}
	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 class LethalBotTalkEvent : UnityEvent<LethalBotVoice, float>
	{
	}
	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;

		public LethalBotBlacklistedItem[] BlacklistedItems;
	}
	[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}";
		}
	}
	[Serializable]
	public class LethalBotBlacklistedItem
	{
		public string itemName;

		public bool hasScrapValue;

		public int scrapValue;

		public float x;

		public float y;

		public float z;

		[JsonIgnore]
		public Vector3 SavedPosition
		{
			get
			{
				//IL_0012: Unknown result type (might be due to invalid IL or missing references)
				return new Vector3(x, y, z);
			}
			set
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_000d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0019: Unknown result type (might be due to invalid IL or missing references)
				x = value.x;
				y = value.y;
				z = value.z;
			}
		}

		public LethalBotBlacklistedItem()
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			itemName = string.Empty;
			SavedPosition = Vector3.zero;
			hasScrapValue = false;
			scrapValue = 0;
		}

		public LethalBotBlacklistedItem(GrabbableObject blacklistedItem)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			itemName = blacklistedItem.itemProperties.itemName;
			SavedPosition = ((Component)blacklistedItem).transform.position;
			if (blacklistedItem.itemProperties.isScrap)
			{
				hasScrapValue = true;
				scrapValue = blacklistedItem.scrapValue;
			}
			else
			{
				hasScrapValue = false;
				scrapValue = 0;
			}
		}

		public override string ToString()
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			return $"Blacklisted Item: {itemName}, Saved Position: {SavedPosition}, Scrap Value {scrapValue}";
		}
	}
}
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]}");
					num = i;
					break;
				}
			}
			if (num != -1)
			{
				list.RemoveRange(num, 3);
				List<CodeInstruction> collection = new List<CodeInstruction>
				{
					new CodeInstruction(OpCodes.Ldarg_0, (object)null),
					new CodeInstruction(OpCodes.Ldfld, (object)fieldInfo2),
					new CodeInstruction(OpCodes.Ldfld, (object)fieldInfo3)
				};
				list.InsertRange(num, collection);
				num = -1;
			}
			else
			{
				Plugin.LogError("LethalBot.Patches.ObjectPatches.CaveDwellerPhysicsProp.DiscardItem_Transpiler could not find the localPlayerController reference for animations!");
			}
			for (int j = 0; j < list.Count - 2; j++)
			{
				if (CodeInstructionExtensions.Calls(list[j], methodInfo) && CodeInstructionExtensions.LoadsField(list[j + 1], fieldInfo, false) && CodeInstructionExtensions.LoadsField(list[j + 2], fieldInfo4, false))
				{
					Plugin.LogDebug($"Patching localPlayerController usage at index {j}...");
					Plugin.LogDebug($"Original Codes: 1: {list[j]}, 2: {list[j + 1]}, 3: {list[j + 2]}");
					num = j;
					break;
				}
			}
			if (num != -1)
			{
				list.RemoveRange(num, 3);
				List<CodeInstruction> collection2 = new List<CodeInstruction>
				{
					new CodeInstruction(OpCodes.Ldarg_0, (object)null),
					new CodeInstruction(OpCodes.Ldfld, (object)fieldInfo2),
					new CodeInstruction(OpCodes.Ldfld, (object)fieldInfo4)
				};
				list.InsertRange(num, collection2);
				num = -1;
			}
			else
			{
				Plugin.LogError("LethalBot.Patches.ObjectPatches.CaveDwellerPhysicsProp.DiscardItem_Transpiler could not find the localPlayerController reference for RPC!");
			}
			Plugin.LogDebug("Finished patching CaveDwellerPhysicsProp.DiscardItem!");
			return list.AsEnumerable();
		}
	}
	[HarmonyPatch(typeof(DeadBodyInfo))]
	public class DeadBodyInfoPatch
	{
		public sealed class DeadBodyInfoMonitor : UpdateLimiter
		{
			private const float UPDATE_INTERVAL = 0.5f;

			private readonly Dictionary<LethalBotAI, bool> lethalBotAIs = new Dictionary<LethalBotAI, bool>();

			internal DeadBodyInfoMonitor()
				: this(0.5f)
			{
			}

			internal DeadBodyInfoMonitor(float updateInterval)
				: base(updateInterval)
			{
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			public void SetBotSeenBody(LethalBotAI bot, bool seenBody = true)
			{
				lethalBotAIs[bot] = seenBody;
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			public bool HasBotSeenBody(LethalBotAI bot)
			{
				return lethalBotAIs.GetValueOrDefault(bot, defaultValue: false);
			}
		}

		public static readonly ConditionalWeakTable<DeadBodyInfo, DeadBodyInfoMonitor> lethalBotDeadBodyInfoMonitor = new ConditionalWeakTable<DeadBodyInfo, DeadBodyInfoMonitor>();

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static DeadBodyInfoMonitor GetOrCreateMonitor(DeadBodyInfo body)
		{
			return lethalBotDeadBodyInfoMonitor.GetValue(body, (DeadBodyInfo _) => new DeadBodyInfoMonitor());
		}

		[HarmonyPatch("DetectIfSeenByLocalPlayer")]
		[HarmonyPostfix]
		private static void DetectIfSeenByLocalPlayer_PostFix(DeadBodyInfo __instance)
		{
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			DeadBodyInfoMonitor orCreateMonitor = GetOrCreateMonitor(__instance);
			if (!orCreateMonitor.CanUpdate())
			{
				return;
			}
			orCreateMonitor.Invalidate();
			LethalBotAI[] lethalBotsAIOwnedByLocal = LethalBotManager.Instance.GetLethalBotsAIOwnedByLocal();
			LethalBotAI[] array = lethalBotsAIOwnedByLocal;
			foreach (LethalBotAI lethalBotAI in array)
			{
				PlayerControllerB npc = lethalBotAI.NpcController.Npc;
				if (!((Object)(object)npc != (Object)null) || orCreateMonitor.HasBotSeenBody(lethalBotAI))
				{
					continue;
				}
				Rigidbody val = null;
				float num = Vector3.Distance(((Component)npc.gameplayCamera).transform.position, ((Component)__instance).transform.position);
				Rigidbody[] bodyParts = __instance.bodyParts;
				foreach (Rigidbody val2 in bodyParts)
				{
					if ((Object)(object)val == (Object)(object)val2)
					{
						continue;
					}
					val = val2;
					if (npc.HasLineOfSightToPosition(((Component)val).transform.position, 30f / (num / 5f), 60, -1f, -1))
					{
						if (num < 10f)
						{
							npc.JumpToFearLevel(0.9f, true);
						}
						else
						{
							npc.JumpToFearLevel(0.55f, true);
						}
						orCreateMonitor.SetBotSeenBody(lethalBotAI);
						break;
					}
				}
			}
		}

		[HarmonyPatch("Start")]
		[HarmonyTranspiler]
		public static IEnumerable<CodeInstruction> Start_Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator generator)
		{
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Expected O, but got Unknown
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Expected O, but got Unknown
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Expected O, but got Unknown
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: Expected O, but got Unknown
			int num = -1;
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			for (int i = 0; i < list.Count - 8; i++)
			{
				if (((object)list[i]).ToString().StartsWith("ldarg.0 NULL") && ((object)list[i + 3]).ToString().StartsWith("ldarg.0 NULL") && ((object)list[i + 8]).ToString() == "ldstr \"PlayerRagdoll\"")
				{
					num = i;
					break;
				}
			}
			if (num > -1)
			{
				List<Label> labels = list[num + 3].labels;
				Label label = generator.DefineLabel();
				labels.Add(label);
				List<CodeInstruction> list2 = new List<CodeInstruction>();
				list2.Add(new CodeInstruction(OpCodes.Ldarg_0, (object)null));
				list2.Add(new CodeInstruction(OpCodes.Ldfld, (object)AccessTools.Field(typeof(DeadBodyInfo), "playerObjectId")));
				list2.Add(new CodeInstruction(OpCodes.Call, (object)PatchesUtil.IsIdPlayerLethalBotMethod));
				list2.Add(new CodeInstruction(OpCodes.Brtrue_S, (object)label));
				List<CodeInstruction> collection = list2;
				list.InsertRange(num, collection);
				num = -1;
			}
			else
			{
				Plugin.LogError("LethalBot.Patches.ObjectsPatches.DeadBodyInfoPatch.Start_Transpiler remplace with correct tag if bot.");
			}
			return list.AsEnumerable();
		}

		[HarmonyPatch("OnDestroy")]
		[HarmonyPostfix]
		private static void OnDestroy_Postfix(DeadBodyInfo __instance)
		{
			lethalBotDeadBodyInfoMonitor.Remove(__instance);
		}
	}
	[HarmonyPatch(typeof(GrabbableObject))]
	public class GrabbableObjectPatch
	{
		[HarmonyPatch("Start")]
		[HarmonyPostfix]
		private static void Start_Postfix(GrabbableObject __instance)
		{
			LethalBotManager.Instance.GrabbableObjectSpawned(__instance);
		}

		[HarmonyPatch("SetControlTipsForItem")]
		[HarmonyPrefix]
		[HarmonyPriority(800)]
		private static bool SetControlTipsForItem_PreFix(GrabbableObject __instance)
		{
			return !LethalBotManager.Instance.IsAnLethalBotAiOwnerOfObject(__instance);
		}

		[HarmonyPatch("DestroyObjectInHand")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> DestroyObjectInHand_Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator generator)
		{
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0104: 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");
			MethodInfo methodInfo2 = AccessTools.Method(typeof(Object), "op_Equality", (Type[])null, (Type[])null);
			FieldInfo fieldInfo2 = AccessTools.Field(typeof(GrabbableObject), "playerHeldBy");
			for (int i = 0; i < list.Count - 4; i++)
			{
				if (CodeInstructionExtensions.IsLdarg(list[i], (int?)0) && CodeInstructionExtensions.LoadsField(list[i + 1], fieldInfo2, false) && CodeInstructionExtensions.Calls(list[i + 2], methodInfo) && CodeInstructionExtensions.LoadsField(list[i + 3], fieldInfo, false) && CodeInstructionExtensions.Calls(list[i + 4], methodInfo2))
				{
					num = i;
					break;
				}
			}
			if (num > -1)
			{
				list.RemoveRange(num + 2, 3);
				list.Insert(num + 2, new CodeInstruction(OpCodes.Call, (object)PatchesUtil.IsPlayerLocalOrLethalBotOwnerLocalMethod));
				num = -1;
			}
			else
			{
				Plugin.LogError("LethalBot.Patches.ObjectsPatches.DestroyObjectInHand_Transpiler could not remove check if holding player is bot");
			}
			return list.AsEnumerable();
		}

		[HarmonyPatch("DiscardItemOnClient")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> DiscardItemOnClient_Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator generator)
		{
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Expected O, but got Unknown
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Expected O, but got Unknown
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Expected O, but got Unknown
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Expected O, but got Unknown
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			//IL_012a: Expected O, but got Unknown
			//IL_0135: Unknown result type (might be due to invalid IL or missing references)
			//IL_013f: Expected O, but got Unknown
			//IL_014c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0156: Expected O, but got Unknown
			int index = 0;
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			LocalBuilder localBuilder = generator.DeclareLocal(typeof(PlayerControllerB));
			MethodInfo methodInfo = AccessTools.PropertyGetter(typeof(HUDManager), "Instance");
			MethodInfo methodInfo2 = AccessTools.Method(typeof(HUDManager), "ClearControlTips", (Type[])null, (Type[])null);
			FieldInfo fieldInfo = AccessTools.Field(typeof(GrabbableObject), "playerHeldBy");
			List<CodeInstruction> collection = new List<CodeInstruction>
			{
				new CodeInstruction(OpCodes.Ldarg_0, (object)null),
				new CodeInstruction(OpCodes.Ldfld, (object)fieldInfo),
				new CodeInstruction(OpCodes.Stloc, (object)localBuilder)
			};
			list.InsertRange(index, collection);
			index = -1;
			for (int i = 0; i < list.Count - 1; i++)
			{
				if (CodeInstructionExtensions.Calls(list[i], methodInfo) && CodeInstructionExtensions.Calls(list[i + 1], methodInfo2))
				{
					index = i;
					break;
				}
			}
			if (index > -1)
			{
				Label label = generator.DefineLabel();
				CodeInstruction val = new CodeInstruction(OpCodes.Nop, (object)null);
				val.labels.Add(label);
				list.Insert(index + 2, val);
				collection = new List<CodeInstruction>
				{
					new CodeInstruction(OpCodes.Ldloc, (object)localBuilder),
					new CodeInstruction(OpCodes.Call, (object)PatchesUtil.IsPlayerLethalBotMethod),
					new CodeInstruction(OpCodes.Brtrue_S, (object)label)
				};
				list.InsertRange(index, collection);
				index = -1;
			}
			else
			{
				Plugin.LogError("LethalBot.Patches.ObjectsPatches.DiscardItemOnClient_Transpiler could not remove check if holding player is bot");
			}
			return list.AsEnumerable();
		}

		[HarmonyPatch("DiscardItem")]
		[HarmonyPrefix]
		private static void DiscardItem_PreFix(GrabbableObject __instance)
		{
			PlayerControllerB playerHeldBy = __instance.playerHeldBy;
			if (!((Object)(object)playerHeldBy == (Object)null) && !((NetworkBehaviour)__instance).IsOwner && LethalBotManager.Instance.IsPlayerLethalBot(playerHeldBy))
			{
				__instance.playerHeldBy.IsInspectingItem = false;
				__instance.playerHeldBy.activatingItem = false;
			}
		}

		[HarmonyPatch("DiscardItem")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> DiscardItem_Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator generator)
		{
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Expected O, but got Unknown
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Expected O, but got Unknown
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Expected O, but got Unknown
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Expected O, but got Unknown
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Expected O, but got Unknown
			int num = -1;
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			MethodInfo methodInfo = AccessTools.PropertyGetter(typeof(HUDManager), "Instance");
			MethodInfo methodInfo2 = AccessTools.Method(typeof(HUDManager), "ClearControlTips", (Type[])null, (Type[])null);
			FieldInfo fieldInfo = AccessTools.Field(typeof(GrabbableObject), "playerHeldBy");
			for (int i = 0; i < list.Count - 1; i++)
			{
				if (CodeInstructionExtensions.Calls(list[i], methodInfo) && CodeInstructionExtensions.Calls(list[i + 1], methodInfo2))
				{
					num = i;
					break;
				}
			}
			if (num > -1)
			{
				Label label = generator.DefineLabel();
				CodeInstruction val = new CodeInstruction(OpCodes.Nop, (object)null);
				val.labels.Add(label);
				list.Insert(num + 2, val);
				List<CodeInstruction> collection = new List<CodeInstruction>
				{
					new CodeInstruction(OpCodes.Ldarg_0, (object)null),
					new CodeInstruction(OpCodes.Ldfld, (object)fieldInfo),
					new CodeInstruction(OpCodes.Call, (object)PatchesUtil.IsPlayerLethalBotMethod),
					new CodeInstruction(OpCodes.Brtrue_S, (object)label)
				};
				list.InsertRange(num, collection);
				num = -1;
			}
			else
			{
				Plugin.LogError("LethalBot.Patches.ObjectsPatches.DiscardItem_Transpiler could not remove check if holding player is bot");
			}
			return list.AsEnumerable();
		}

		[HarmonyPatch("GrabItemOnClient")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> GrabItemOnClient_Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator generator)
		{
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Expected O, but got Unknown
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Expected O, but got Unknown
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Expected O, but got Unknown
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Expected O, but got Unknown
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Expected O, but got Unknown
			int num = -1;
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			MethodInfo methodInfo = AccessTools.Method(typeof(GrabbableObject), "SetControlTipsForItem", (Type[])null, (Type[])null);
			FieldInfo fieldInfo = AccessTools.Field(typeof(GrabbableObject), "playerHeldBy");
			for (int i = 0; i < list.Count - 1; i++)
			{
				if (CodeInstructionExtensions.IsLdarg(list[i], (int?)0) && CodeInstructionExtensions.Calls(list[i + 1], methodInfo))
				{
					num = i;
					break;
				}
			}
			if (num > -1)
			{
				Label label = generator.DefineLabel();
				CodeInstruction val = new CodeInstruction(OpCodes.Nop, (object)null);
				val.labels.Add(label);
				list.Insert(num + 2, val);
				List<CodeInstruction> collection = new List<CodeInstruction>
				{
					new CodeInstruction(OpCodes.Ldarg_0, (object)null),
					new CodeInstruction(OpCodes.Ldfld, (object)fieldInfo),
					new CodeInstruction(OpCodes.Call, (object)PatchesUtil.IsPlayerLethalBotMethod),
					new CodeInstruction(OpCodes.Brtrue_S, (object)label)
				};
				list.InsertRange(num, collection);
				num = -1;
			}
			else
			{
				Plugin.LogError("LethalBot.Patches.ObjectsPatches.GrabItemOnClient_Transpiler could not remove check if holding player is bot");
			}
			return list.AsEnumerable();
		}

		[HarmonyPatch("EquipItem")]
		[HarmonyTranspiler]
		public static IEnumerable<CodeInstruction> EquipItem_Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator generator)
		{
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Expected O, but got Unknown
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Expected O, but got Unknown
			//IL_011e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0128: Expected O, but got Unknown
			//IL_0133: Unknown result type (might be due to invalid IL or missing references)
			//IL_013d: Expected O, but got Unknown
			//IL_014a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0154: Expected O, but got Unknown
			int num = -1;
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			MethodInfo methodInfo = AccessTools.PropertyGetter(typeof(HUDManager), "Instance");
			MethodInfo methodInfo2 = AccessTools.Method(typeof(HUDManager), "ClearControlTips", (Type[])null, (Type[])null);
			MethodInfo methodInfo3 = AccessTools.Method(typeof(GrabbableObject), "SetControlTipsForItem", (Type[])null, (Type[])null);
			FieldInfo fieldInfo = AccessTools.Field(typeof(GrabbableObject), "playerHeldBy");
			for (int i = 0; i < list.Count - 3; i++)
			{
				if (CodeInstructionExtensions.Calls(list[i], methodInfo) && CodeInstructionExtensions.Calls(list[i + 1], methodInfo2) && CodeInstructionExtensions.IsLdarg(list[i + 2], (int?)0) && CodeInstructionExtensions.Calls(list[i + 3], methodInfo3))
				{
					num = i;
					break;
				}
			}
			if (num > -1)
			{
				Label label = generator.DefineLabel();
				CodeInstruction val = new CodeInstruction(OpCodes.Nop, (object)null);
				val.labels.Add(label);
				list.Insert(num + 4, val);
				List<CodeInstruction> collection = new List<CodeInstruction>
				{
					new CodeInstruction(OpCodes.Ldarg_0, (object)null),
					new CodeInstruction(OpCodes.Ldfld, (object)fieldInfo),
					new CodeInstruction(OpCodes.Call, (object)PatchesUtil.IsPlayerLethalBotMethod),
					new CodeInstruction(OpCodes.Brtrue_S, (object)label)
				};
				list.InsertRange(num, collection);
				num = -1;
			}
			else
			{
				Plugin.LogError("LethalBot.Patches.ObjectsPatches.EquipItem_Transpiler could not remove check if holding player is bot");
			}
			return list.AsEnumerable();
		}
	}
	[HarmonyPatch(typeof(RagdollGrabbableObject))]
	public class RagdollGrabbableObjectPatch
	{
		[HarmonyPatch("Start")]
		[HarmonyPostfix]
		private static void Start_Postfix(RagdollGrabbableObject __instance)
		{
			LethalBotManager.Instance.GrabbableObjectSpawned((GrabbableObject)(object)__instance);
		}

		[HarmonyPatch("Update")]
		[HarmonyPrefix]
		private static bool Update_PreFix(RagdollGrabbableObject __instance, ref bool ___foundRagdollObject)
		{
			int bodyID = __instance.bodyID;
			if (bodyID == -2)
			{
				if ((Object)(object)__instance.ragdoll == (Object)null)
				{
					return false;
				}
				___foundRagdollObject = true;
				((GrabbableObject)__instance).grabbableToEnemies = false;
				return true;
			}
			if (___foundRagdollObject && (Object)(object)StartOfRound.Instance.allPlayerScripts[bodyID].deadBody != (Object)null && (Object)(object)__instance.ragdoll != (Object)null && bodyID != (int)__instance.ragdoll.playerScript.playerClientId)
			{
				___foundRagdollObject = false;
			}
			return true;
		}

		[HarmonyPatch("Update")]
		[HarmonyPostfix]
		private static void Update_PostFix(RagdollGrabbableObject __instance)
		{
			if (__instance.bodyID == -2)
			{
				((GrabbableObject)__instance).grabbableToEnemies = false;
			}
		}
	}
	[HarmonyPatch(typeof(ShotgunItem))]
	public class ShotgunItemPatch
	{
		[HarmonyPatch("ShootGunAndSync")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> ShootGunAndSync_Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator generator)
		{
			bool flag = false;
			int num = 0;
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			MethodInfo methodInfo = AccessTools.PropertyGetter(typeof(GameNetworkManager), "Instance");
			FieldInfo fieldInfo = AccessTools.Field(typeof(GameNetworkManager), "localPlayerController");
			FieldInfo operand = AccessTools.Field(typeof(ShotgunItem), "previousPlayerHeldBy");
			Plugin.LogDebug("Beginning to patch ShotgunItem.ShootGunAndSync!");
			for (int i = 0; i < list.Count - 1; i++)
			{
				if (CodeInstructionExtensions.Calls(list[i], methodInfo) && CodeInstructionExtensions.LoadsField(list[i + 1], fieldInfo, false))
				{
					Plugin.LogDebug($"Patching localPlayerController at index {i}...");
					Plugin.LogDebug($"Original Codes: 1: {list[i]} and 2: {list[i + 1]}");
					list[i].opcode = OpCodes.Ldarg_0;
					list[i].operand = null;
					list[i + 1].opcode = OpCodes.Ldfld;
					list[i + 1].operand = operand;
					flag = true;
					num++;
				}
			}
			if (!flag)
			{
				Plugin.LogError("LethalBot.Patches.ObjectPatches.ShotgunItem.ShootGunAndSync_Transpiler could not check if player local or bot local 1");
			}
			else
			{
				Plugin.LogDebug($"Patched out localPlayerController {num} times!");
			}
			return list.AsEnumerable();
		}

		[HarmonyPatch("ShootGun")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> ShootGun_Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator generator)
		{
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0126: Expected O, but got Unknown
			//IL_01d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e3: Expected O, but got Unknown
			//IL_01eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f5: Expected O, but got Unknown
			//IL_0200: Unknown result type (might be due to invalid IL or missing references)
			//IL_020a: 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");
			MethodInfo methodInfo2 = AccessTools.Method(typeof(Object), "op_Equality", (Type[])null, (Type[])null);
			FieldInfo fieldInfo2 = AccessTools.Field(typeof(GrabbableObject), "playerHeldBy");
			Plugin.LogDebug("Beginning to patch ShotgunItem.ShootGun!");
			for (int i = 0; i < list.Count - 2; i++)
			{
				if (CodeInstructionExtensions.Calls(list[i], methodInfo) && CodeInstructionExtensions.LoadsField(list[i + 1], fieldInfo, false) && CodeInstructionExtensions.Calls(list[i + 2], methodInfo2))
				{
					Plugin.LogDebug($"Patching localPlayerController comparison at index {i}...");
					Plugin.LogDebug($"Original Codes: 1: {list[i]}, 2: {list[i + 1]}, 3: {list[i + 2]}");
					num = i;
					break;
				}
			}
			if (num != -1)
			{
				list.RemoveRange(num, 3);
				list.Insert(num, new CodeInstruction(OpCodes.Call, (object)PatchesUtil.IsPlayerLocalOrLethalBotOwnerLocalMethod));
				num = -1;
			}
			else
			{
				Plugin.LogError("LethalBot.Patches.ObjectPatches.ShotgunItem.ShootGun_Transpiler could not find the localPlayerController reference!");
			}
			for (int j = 0; j < list.Count - 1; j++)
			{
				if (list[j].opcode == OpCodes.Ldc_I4_1 && list[j + 1].opcode == OpCodes.Stloc_0)
				{
					Plugin.LogDebug($"Patching flag assignment at index {j}...");
					Plugin.LogDebug($"Original Codes: 1: {list[j]} and 2: {list[j + 1]}");
					num = j;
					break;
				}
			}
			if (num != -1)
			{
				CodeInstruction item = list[num + 1];
				List<CodeInstruction> collection = new List<CodeInstruction>
				{
					new CodeInstruction(OpCodes.Ldarg_0, (object)null),
					new CodeInstruction(OpCodes.Ldfld, (object)fieldInfo2),
					new CodeInstruction(OpCodes.Call, (object)PatchesUtil.IsPlayerLocalMethod),
					item
				};
				list.RemoveRange(num, 2);
				list.InsertRange(num, collection);
			}
			else
			{
				Plugin.LogError("LethalBot.Patches.ObjectPatches.ShotgunItem.ShootGun_Transpiler could not change the flag!");
			}
			Plugin.LogDebug("Finished patching ShotgunItem.ShootGun!");
			return list.AsEnumerable();
		}

		[HarmonyPatch("ItemInteractLeftRight")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> ItemInteractLeftRight_Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator generator)
		{
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Expected O, but got Unknown
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Expected O, but got Unknown
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Expected O, but got Unknown
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Expected O, but got Unknown
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Expected O, but got Unknown
			bool flag = false;
			int num = 0;
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			MethodInfo methodInfo = AccessTools.Method(typeof(ShotgunItem), "SetSafetyControlTip", (Type[])null, (Type[])null);
			FieldInfo fieldInfo = AccessTools.Field(typeof(GrabbableObject), "playerHeldBy");
			for (int i = 0; i < list.Count - 1; i++)
			{
				if (CodeInstructionExtensions.IsLdarg(list[i], (int?)0) && CodeInstructionExtensions.Calls(list[i + 1], methodInfo))
				{
					Label label = generator.DefineLabel();
					CodeInstruction val = new CodeInstruction(OpCodes.Nop, (object)null);
					val.labels.Add(label);
					list.Insert(i + 2, val);
					List<CodeInstruction> list2 = new List<CodeInstruction>
					{
						new CodeInstruction(OpCodes.Ldarg_0, (object)null),
						new CodeInstruction(OpCodes.Ldfld, (object)fieldInfo),
						new CodeInstruction(OpCodes.Call, (object)PatchesUtil.IsPlayerLethalBotMethod),
						new CodeInstruction(OpCodes.Brtrue_S, (object)label)
					};
					list.InsertRange(i, list2);
					i += list2.Count;
					flag = true;
					num++;
				}
			}
			if (!flag)
			{
				Plugin.LogError("LethalBot.Patches.ObjectsPatches.ShotgunItem.ItemInteractLeftRight_Transpiler could not check if player local for Crouch");
			}
			else
			{
				Plugin.LogDebug($"Patched out SetSafetyControlTip calls for bots in Shotgun code {num} times!");
			}
			return list.AsEnumerable();
		}

		[HarmonyPatch("SetControlTipsForItem")]
		[HarmonyPrefix]
		[HarmonyPriority(800)]
		private static bool SetControlTipsForItem_PreFix(ShotgunItem __instance)
		{
			return !LethalBotManager.Instance.IsAnLethalBotAiOwnerOfObject((GrabbableObject)(object)__instance);
		}

		[HarmonyPatch("SetSafetyControlTip")]
		[HarmonyPrefix]
		[HarmonyPriority(800)]
		private static bool SetSafetyControlTip_PreFix(ShotgunItem __instance)
		{
			return !LethalBotManager.Instance.IsAnLethalBotAiOwnerOfObject((GrabbableObject)(object)__instance);
		}

		[HarmonyPatch("ShootGun")]
		[HarmonyPostfix]
		private static void ShootGun_PostFix(ShotgunItem __instance, Vector3 shotgunPosition, Vector3 shotgunForward)
		{
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: Unknown result type (might be due to invalid IL or missing references)
			//IL_012b: Unknown result type (might be due to invalid IL or missing references)
			LethalBotAI[] lethalBotsAIOwnedByLocal = LethalBotManager.Instance.GetLethalBotsAIOwnedByLocal();
			LethalBotAI[] array = lethalBotsAIOwnedByLocal;
			for (int i = 0; i < array.Length; i++)
			{
				PlayerControllerB val = array[i]?.NpcController?.Npc;
				if ((Object)(object)val == (Object)null || val.isPlayerDead || !val.isPlayerControlled || (Object)(object)((GrabbableObject)__instance).playerHeldBy == (Object)(object)val)
				{
					continue;
				}
				int num = 0;
				Vector3 val2 = ((Component)val).transform.position + new Vector3(0f, 1f, 0f);
				float num2 = Vector3.Distance(val2, ((Component)__instance.shotgunRayPoint).transform.position);
				Vector3 val3 = val2;
				if (Vector3.Angle(shotgunForward, val3 - shotgunPosition) < 30f && !Physics.Linecast(shotgunPosition, val3, StartOfRound.Instance.collidersAndRoomMaskAndDefault, (QueryTriggerInteraction)1))
				{
					if (num2 < 5f)
					{
						num = 100;
					}
					if (num2 < 15f)
					{
						num = 100;
					}
					else if (num2 < 23f)
					{
						num = 40;
					}
					else if (num2 < 30f)
					{
						num = 20;
					}
					val.DamagePlayer(num, true, true, (CauseOfDeath)7, 0, false, __instance.shotgunRayPoint.forward * 30f);
				}
			}
		}
	}
	[HarmonyPatch(typeof(SprayPaintItem))]
	public class SprayPaintItemPatch
	{
		[HarmonyPatch("TrySprayingWeedKillerOnLocalPlayer")]
		[HarmonyPostfix]
		private static void TrySprayingWeedKillerOnLocalPlayer_Postfix(SprayPaintItem __instance, ref CadaverGrowthAI ___cadaverGrowthAI)
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)___cadaverGrowthAI == (Object)null)
			{
				return;
			}
			PlayerControllerB playerHeldBy = ((GrabbableObject)__instance).playerHeldBy;
			if ((Object)(object)playerHeldBy == (Object)null)
			{
				return;
			}
			Vector3 position = ((Component)__instance).transform.position;
			Vector3 forward = ((Component)__instance).transform.forward;
			Vector3 position2 = ((Component)playerHeldBy).transform.position;
			LethalBotAI[] lethalBotsAIOwnedByLocal = LethalBotManager.Instance.GetLethalBotsAIOwnedByLocal();
			LethalBotAI[] array = lethalBotsAIOwnedByLocal;
			foreach (LethalBotAI lethalBotAI in array)
			{
				PlayerControllerB val = lethalBotAI?.NpcController?.Npc;
				if (!((Object)(object)val != (Object)null) || !((Object)(object)playerHeldBy != (Object)(object)val))
				{
					continue;
				}
				PlayerInfection val2 = ___cadaverGrowthAI.playerInfections[val.playerClientId];
				if (val2.infected)
				{
					Vector3 position3 = ((Component)val).transform.position;
					position3.y = position.y;
					Vector3 val3 = position2 - ((Component)val).transform.position;
					if (((Vector3)(ref val3)).sqrMagnitude < 25f && Vector3.Angle(forward, position3 - position) < 40f)
					{
						HealPlayerInfection(val, lethalBotAI, val2, ___cadaverGrowthAI);
					}
				}
			}
		}

		private static void HealPlayerInfection(PlayerControllerB lethalBotController, LethalBotAI lethalBotAI, PlayerInfection infection, CadaverGrowthAI cadaverGrowthAI)
		{
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			LethalBotInfection value = lethalBotAI.BotInfectionData.Value;
			if (value.sprayOnPlayerMeter > 0.33f)
			{
				value.sprayOnPlayerMeter = 0f;
				if (infection.burstMeter > 0f)
				{
					cadaverGrowthAI.BurstFromPlayer(lethalBotController, ((Component)lethalBotController).transform.position, ((Component)lethalBotController).transform.eulerAngles);
					cadaverGrowthAI.SyncBurstFromPlayerRpc((int)lethalBotController.playerClientId, ((Component)lethalBotController).transform.position, ((Component)lethalBotController).transform.eulerAngles);
					return;
				}
				lethalBotController.DamagePlayer(8, true, true, (CauseOfDeath)5, 0, false, default(Vector3));
				cadaverGrowthAI.HealInfection((int)lethalBotController.playerClientId, 0.1f);
				if (lethalBotController.criticallyInjured)
				{
					value.sprayOnPlayerMeter = -0.2f;
				}
			}
			else
			{
				value.sprayOnPlayerMeter += Time.deltaTime;
			}
		}

		[HarmonyPatch("TrySprayingWeedKillerBottle")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> TrySprayingWeedKillerBottle_Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator generator)
		{
			bool flag = false;
			int num = 0;
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			MethodInfo methodInfo = AccessTools.PropertyGetter(typeof(GameNetworkManager), "Instance");
			FieldInfo fieldInfo = AccessTools.Field(typeof(GameNetworkManager), "localPlayerController");
			FieldInfo operand = AccessTools.Field(typeof(GrabbableObject), "playerHeldBy");
			Plugin.LogDebug("Beginning to patch SprayPaintItemPatch.TrySprayingWeedKillerBottle!");
			for (int i = 0; i < list.Count - 1; i++)
			{
				if (CodeInstructionExtensions.Calls(list[i], methodInfo) && CodeInstructionExtensions.LoadsField(list[i + 1], fieldInfo, false))
				{
					Plugin.LogDebug($"Patching localPlayerController at index {i}...");
					Plugin.LogDebug($"Original Codes: 1: {list[i]} and 2: {list[i + 1]}");
					list[i].opcode = OpCodes.Ldarg_0;
					list[i].operand = null;
					list[i + 1].opcode = OpCodes.Ldfld;
					list[i + 1].operand = operand;
					flag = true;
					num++;
				}
			}
			if (!flag)
			{
				Plugin.LogError("LethalBot.Patches.ObjectPatches.SprayPaintItemPatch.TrySprayingWeedKillerBottle_Transpiler could not check if player local or bot local 1");
			}
			else
			{
				Plugin.LogDebug($"Patched out localPlayerController {num} times!");
			}
			return list.AsEnumerable();
		}

		[HarmonyPatch("CheckForCadaverPlantsInSprayPath")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> CheckForCadaverPlantsInSprayPath_Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator generator)
		{
			bool flag = false;
			int num = 0;
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			MethodInfo methodInfo = AccessTools.PropertyGetter(typeof(GameNetworkManager), "Instance");
			FieldInfo fieldInfo = AccessTools.Field(typeof(GameNetworkManager), "localPlayerController");
			FieldInfo operand = AccessTools.Field(typeof(GrabbableObject), "playerHeldBy");
			Plugin.LogDebug("Beginning to patch SprayPaintItemPatch.CheckForCadaverPlantsInSprayPath!");
			for (int i = 0; i < list.Count - 1; i++)
			{
				if (CodeInstructionExtensions.Calls(list[i], methodInfo) && CodeInstructionExtensions.LoadsField(list[i + 1], fieldInfo, false))
				{
					Plugin.LogDebug($"Patching localPlayerController at index {i}...");
					Plugin.LogDebug($"Original Codes: 1: {list[i]} and 2: {list[i + 1]}");
					list[i].opcode = OpCodes.Ldarg_0;
					list[i].operand = null;
					list[i + 1].opcode = OpCodes.Ldfld;
					list[i + 1].operand = operand;
					flag = true;
					num++;
				}
			}
			if (!flag)
			{
				Plugin.LogError("LethalBot.Patches.ObjectPatches.SprayPaintItemPatch.CheckForCadaverPlantsInSprayPath_Transpiler could not check if player local or bot local 1");
			}
			else
			{
				Plugin.LogDebug($"Patched out localPlayerController {num} times!");
			}
			return list.AsEnumerable();
		}

		[HarmonyPatch("CheckForWeedsInSprayPath")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> CheckForWeedsInSprayPath_Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator generator)
		{
			bool flag = false;
			int num = 0;
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			MethodInfo methodInfo = AccessTools.PropertyGetter(typeof(GameNetworkManager), "Instance");
			FieldInfo fieldInfo = AccessTools.Field(typeof(GameNetworkManager), "localPlayerController");
			FieldInfo operand = AccessTools.Field(typeof(GrabbableObject), "playerHeldBy");
			Plugin.LogDebug("Beginning to patch SprayPaintItemPatch.CheckForWeedsInSprayPath!");
			for (int i = 0; i < list.Count - 1; i++)
			{
				if (CodeInstructionExtensions.Calls(list[i], methodInfo) && CodeInstructionExtensions.LoadsField(list[i + 1], fieldInfo, false))
				{
					Plugin.LogDebug($"Patching localPlayerController at index {i}...");
					Plugin.LogDebug($"Original Codes: 1: {list[i]} and 2: {list[i + 1]}");
					list[i].opcode = OpCodes.Ldarg_0;
					list[i].operand = null;
					list[i + 1].opcode = OpCodes.Ldfld;
					list[i + 1].operand = operand;
					flag = true;
					num++;
				}
			}
			if (!flag)
			{
				Plugin.LogError("LethalBot.Patches.ObjectPatches.SprayPaintItemPatch.CheckForWeedsInSprayPath_Transpiler could not check if player local or bot local 1");
			}
			else
			{
				Plugin.LogDebug($"Patched out localPlayerController {num} times!");
			}
			return list.AsEnumerable();
		}

		[HarmonyPatch("TrySpraying")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> TrySpraying_Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator generator)
		{
			bool flag = false;
			int num = 0;
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			MethodInfo methodInfo = AccessTools.PropertyGetter(typeof(GameNetworkManager), "Instance");
			FieldInfo fieldInfo = AccessTools.Field(typeof(GameNetworkManager), "localPlayerController");
			FieldInfo operand = AccessTools.Field(typeof(GrabbableObject), "playerHeldBy");
			Plugin.LogDebug("Beginning to patch SprayPaintItemPatch.TrySpraying!");
			for (int i = 0; i < list.Count - 1; i++)
			{
				if (CodeInstructionExtensions.Calls(list[i], methodInfo) && CodeInstructionExtensions.LoadsField(list[i + 1], fieldInfo, false))
				{
					Plugin.LogDebug($"Patching localPlayerController at index {i}...");
					Plugin.LogDebug($"Original Codes: 1: {list[i]} and 2: {list[i + 1]}");
					list[i].opcode = OpCodes.Ldarg_0;
					list[i].operand = null;
					list[i + 1].opcode = OpCodes.Ldfld;
					list[i + 1].operand = operand;
					flag = true;
					num++;
				}
			}
			if (!flag)
			{
				Plugin.LogError("LethalBot.Patches.ObjectPatches.SprayPaintItemPatch.TrySpraying_Transpiler could not check if player local or bot local 1");
			}
			else
			{
				Plugin.LogDebug($"Patched out localPlayerController {num} times!");
			}
			return list.AsEnumerable();
		}
	}
	[HarmonyPatch(typeof(StunGrenadeItem))]
	public class StunGrenadeItemPatch
	{
		[HarmonyPatch("SetControlTipForGrenade")]
		[HarmonyPrefix]
		private static bool SetControlTipForGrenade_PreFix(StunGrenadeItem __instance)
		{
			if (LethalBotManager.Instance.IsAnLethalBotAiOwnerOfObject((GrabbableObject)(object)__instance))
			{
				return false;
			}
			return true;
		}

		[HarmonyPatch("StunExplosion")]
		[HarmonyPostfix]
		private static void StunExplosion_PostFix(Vector3 explosionPosition, bool isHeldItem, PlayerControllerB playerHeldBy)
		{
		}
	}
	[HarmonyPatch(typeof(TetraChemicalItem))]
	public class TetraChemicalItemPatch
	{
		[HarmonyPatch("Update")]
		[HarmonyPostfix]
		public static void Update_Postfix(TetraChemicalItem __instance, ref bool ___emittingGas, ref PlayerControllerB ___previousPlayerHeldBy)
		{
			if (___emittingGas && ((NetworkBehaviour)___previousPlayerHeldBy).IsOwner && ___previousPlayerHeldBy.isPlayerControlled && LethalBotManager.Instance.IsPlayerLethalBot(___previousPlayerHeldBy) && (__instance.localHelmetSFX.isPlaying || !__instance.thisAudioSource.isPlaying))
			{
				__instance.localHelmetSFX.Stop();
				__instance.thisAudioSource.clip = __instance.releaseGasSFX;
				__instance.thisAudioSource.Play();
				__instance.thisAudioSource.PlayOneShot(__instance.twistCanSFX);
			}
		}
	}
}
namespace LethalBots.Patches.NpcPatches
{
	[HarmonyPatch(typeof(EnemyAICollisionDetect))]
	public class EnemyAICollisionDetectPatch
	{
		[HarmonyPatch("OnTriggerStay")]
		[HarmonyPrefix]
		private static void Prefix(EnemyAICollisionDetect __instance, Collider other)
		{
			if (__instance.mainScript is LethalBotAI)
			{
				PlayerControllerB componentInParent = ((Component)other).gameObject.GetComponentInParent<PlayerControllerB>();
				if ((Object)(object)componentInParent != (Object)null)
				{
					Physics.IgnoreCollision(((Component)__instance).GetComponent<Collider>(), other);
				}
			}
		}
	}
	[HarmonyPatch(typeof(EnemyAI))]
	public class EnemyAIPatch
	{
		[HarmonyPatch("ChangeOwnershipOfEnemy")]
		[HarmonyPrefix]
		private static bool ChangeOwnershipOfEnemy_PreFix(ref ulong newOwnerClientId)
		{
			Plugin.LogDebug($"[PREFIX]: Try ChangeOwnershipOfEnemy newOwnerClientId : {(int)newOwnerClientId}");
			if (newOwnerClientId > 200000)
			{
				LethalBotAI lethalBotAI = LethalBotManager.Instance.GetLethalBotAI((int)(newOwnerClientId - 200000));
				if ((Object)(object)lethalBotAI == (Object)null)
				{
					Plugin.LogDebug($"Could not find lethalBot with id : {(int)(newOwnerClientId - 200000)}, aborting ChangeOwnershipOfEnemy.");
					return false;
				}
				Plugin.LogDebug($"ChangeOwnershipOfEnemy not on lethalBot but on lethalBot owner : {((NetworkBehaviour)lethalBotAI).OwnerClientId}");
				newOwnerClientId = ((NetworkBehaviour)lethalBotAI).OwnerClientId;
			}
			return true;
		}

		[HarmonyPatch("ChangeOwnershipOfEnemy")]
		[HarmonyPostfix]
		private static void ChangeOwnershipOfEnemy_PostFix(EnemyAI __instance, ulong newOwnerClientId)
		{
			LethalBotAI lethalBotAI = __instance as LethalBotAI;
			if ((Object)(object)lethalBotAI != (Object)null)
			{
				Plugin.LogDebug($"[POSTFIX]: Try ChangeOwnershipOfEnemy for lethalBot newOwnerClientId : {(int)newOwnerClientId}");
				lethalBotAI.ChangeOwnershipOfBotInventoryServerRpc(newOwnerClientId);
				lethalBotAI.ChangeNpcOwnershipOfBotServerRpc(newOwnerClientId);
				if (Plugin.IsModLethalPhonesLoaded)
				{
					lethalBotAI.ChangeOwnershipOfLethalPhoneServerRpc(newOwnerClientId);
				}
			}
		}

		[HarmonyPatch("HitEnemyOnLocalClient")]
		[HarmonyPrefix]
		private static bool HitEnemyOnLocalClient(EnemyAI __instance)
		{
			if (__instance is LethalBotAI)
			{
				return false;
			}
			return true;
		}

		[HarmonyPatch("Start")]
		[HarmonyPostfix]
		private static void Start_Postfix(EnemyAI __instance)
		{
			if (!(__instance is LethalBotAI) && !RoundManager.Instance.SpawnedEnemies.Contains(__instance))
			{
				RoundManager.Instance.SpawnedEnemies.Add(__instance);
			}
			int num = 469762048;
			__instance.agentMask |= num;
			NavMeshAgent agent = __instance.agent;
			agent.areaMask |= num;
		}

		[HarmonyPatch("MeetsStandardPlayerCollisionConditions")]
		[HarmonyTranspiler]
		public static IEnumerable<CodeInstruction> MeetsStandardPlayerCollisionConditions_Transpiler(IEnumerable<CodeInstruction> instructions)
		{
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Expected O, but got Unknown
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: Expected O, but got Unknown
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			//IL_011a: Expected O, but got Unknown
			int num = -1;
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			for (int i = 0; i < list.Count - 8; i++)
			{
				if (list[i].opcode == OpCodes.Brtrue && list[i + 1].opcode == OpCodes.Ldloc_0 && list[i + 2].opcode == OpCodes.Call && list[i + 3].opcode == OpCodes.Ldfld && list[i + 4].opcode == OpCodes.Call && list[i + 8].opcode == OpCodes.Ldarg_0)
				{
					num = i;
					break;
				}
			}
			if (num > -1)
			{
				List<CodeInstruction> collection = new List<CodeInstruction>
				{
					new CodeInstruction(OpCodes.Ldarg_1, (object)null),
					new CodeInstruction(OpCodes.Call, (object)PatchesUtil.IsColliderFromLocalOrLethalBotOwnerLocalMethod),
					new CodeInstruction(OpCodes.Brtrue_S, (object)list[num + 8].labels.First())
				};
				list.InsertRange(num + 1, collection);
			}
			else
			{
				Plugin.LogError("LethalBot.Patches.NpcPatches.EnemyAIPatch.MeetsStandardPlayerCollisionConditions_Transpiler could not insert instruction if is lethalBot for \"component != GameNetworkManager.Instance.localPlayerController\".");
			}
			return list.AsEnumerable();
		}
	}
	[HarmonyPatch(typeof(PlayerControllerB))]
	public class PlayerControllerBPatch
	{
		[HarmonyPatch("Update")]
		[HarmonyAfter(new string[] { "MoreEmotes" })]
		[HarmonyPrefix]
		private static bool Update_PreFix(PlayerControllerB __instance, ref bool ___isCameraDisabled, bool ___isJumping, bool ___isFallingFromJump, ref float ___crouchMeter, ref bool ___isWalking, ref float ___playerSlidingTimer, ref bool ___disabledJetpackControlsThisFrame, ref bool ___startedJetpackControls, ref float ___upperBodyAnimationsWeight, ref bool ___throwingObject, ref float ___timeSinceSwitchingSlots, ref float ___timeSinceTakingGravityDamage, ref bool ___teleportingThisFrame, ref float ___previousFrameDeltaTime, ref float ___cameraUp, ref float ___updatePlayerLookInterval, ref float ___bloodDropTimer)
		{
			LethalBotAI lethalBotAI = LethalBotManager.Instance.GetLethalBotAI(__instance);
			if ((Object)(object)lethalBotAI == (Object)null)
			{
				return true;
			}
			NpcController npcController = lethalBotAI.NpcController;
			if (npcController != null)
			{
				npcController.IsCameraDisabled = ___isCameraDisabled;
				npcController.IsJumping = ___isJumping;
				npcController.IsFallingFromJump = ___isFallingFromJump;
				npcController.CrouchMeter = ___crouchMeter;
				npcController.IsWalking = ___isWalking;
				npcController.PlayerSlidingTimer = ___playerSlidingTimer;
				npcController.DisabledJetpackControlsThisFrame = ___disabledJetpackControlsThisFrame;
				npcController.StartedJetpackControls = ___startedJetpackControls;
				npcController.UpperBodyAnimationsWeight = ___upperBodyAnimationsWeight;
				npcController.ThrowingObject.Apply(___throwingObject);
				npcController.TimeSinceSwitchingSlots.Apply(___timeSinceSwitchingSlots);
				npcController.TimeSinceTakingGravityDamage = ___timeSinceTakingGravityDamage;
				npcController.TeleportingThisFrame = ___teleportingThisFrame;
				npcController.PreviousFrameDeltaTime = ___previousFrameDeltaTime;
				npcController.CameraUp = ___cameraUp;
				npcController.UpdatePlayerLookInterval = ___updatePlayerLookInterval;
				npcController.BloodDropTimer = ___bloodDropTimer;
				lethalBotAI.UpdateController();
				___isCameraDisabled = npcController.IsCameraDisabled;
				___crouchMeter = npcController.CrouchMeter;
				___isWalking = npcController.IsWalking;
				___playerSlidingTimer = npcController.PlayerSlidingTimer;
				___startedJetpackControls = npcController.StartedJetpackControls;
				___upperBodyAnimationsWeight = npcController.UpperBodyAnimationsWeight;
				___throwingObject = npcController.ThrowingObject;
				___timeSinceSwitchingSlots = npcController.TimeSinceSwitchingSlots;
				___timeSinceTakingGravityDamage = npcController.TimeSinceTakingGravityDamage;
				___teleportingThisFrame = npcController.TeleportingThisFrame;
				___previousFrameDeltaTime = npcController.PreviousFrameDeltaTime;
				___cameraUp = npcController.CameraUp;
				___updatePlayerLookInterval = npcController.UpdatePlayerLookInterval;
				___bloodDropTimer = npcController.BloodDropTimer;
			}
			return false;
		}

		[HarmonyPatch("LateUpdate")]
		[HarmonyPrefix]
		private static bool LateUpdate_PreFix(PlayerControllerB __instance, ref bool ___isWalking, ref bool ___updatePositionForNewlyJoinedClient, ref float ___updatePlayerLookInterval, ref float ___limpMultiplier, int ___playerMask)
		{
			LethalBotAI lethalBotAI = LethalBotManager.Instance.GetLethalBotAI(__instance);
			if ((Object)(object)lethalBotAI != (Object)null)
			{
				NpcController npcController = lethalBotAI.NpcController;
				if (npcController != null)
				{
					npcController.IsWalking = ___isWalking;
					npcController.UpdatePositionForNewlyJoinedClient = ___updatePositionForNewlyJoinedClient;
					npcController.UpdatePlayerLookInterval = ___updatePlayerLookInterval;
					npcController.LimpMultiplier = ___limpMultiplier;
					npcController.PlayerMask = ___playerMask;
					npcController.LateUpdate();
					___isWalking = npcController.IsWalking;
					___updatePositionForNewlyJoinedClient = npcController.UpdatePositionForNewlyJoinedClient;
					___updatePlayerLookInterval = npcController.UpdatePlayerLookInterval;
					___limpMultiplier = npcController.LimpMultiplier;
				}
				return false;
			}
			return true;
		}

		[HarmonyPatch("DamagePlayer")]
		[HarmonyPrefix]
		[HarmonyPriority(0)]
		private static bool DamagePlayer_PreFix(PlayerControllerB __instance, bool __runOriginal, int damageNumber, bool hasDamageSFX = true, bool callRPC = true, CauseOfDeath causeOfDeath = 0, int deathAnimation = 0, bool fallDamage = false, Vector3 force = default(Vector3))
		{
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			if (!__runOriginal)
			{
				return true;
			}
			LethalBotAI lethalBotAI = LethalBotManager.Instance.GetLethalBotAI(__instance);
			if ((Object)(object)lethalBotAI != (Object)null)
			{
				Plugin.LogDebug($"SyncDamageLethalBot called from game code on LOCAL client #{((NetworkBehaviour)lethalBotAI).NetworkManager.LocalClientId}, lethalBot object: Bot #{lethalBotAI.BotId}");
				lethalBotAI.DamageLethalBot(damageNumber, hasDamageSFX, callRPC, causeOfDeath, deathAnimation, fallDamage, force);
				return true;
			}
			return true;
		}

		[HarmonyPatch("MakeCriticallyInjuredClientRpc")]
		[HarmonyPostfix]
		public static void MakeCriticallyInjuredClientRpc_Prefix(PlayerControllerB __instance, bool __runOriginal)
		{
			if (__runOriginal)
			{
				LethalBotAI lethalBotAI = LethalBotManager.Instance.GetLethalBotAI(__instance);
				if ((Object)(object)lethalBotAI != (Object)null)
				{
					Plugin.LogDebug($"MakeCriticallyInjuredClientRpc called from game code on LOCAL client #{((NetworkBehaviour)lethalBotAI).NetworkManager.LocalClientId}, lethalBot object: Bot #{lethalBotAI.BotId}");
					__instance.playerBodyAnimator.SetBool("Limp", true);
				}
			}
		}

		[HarmonyPatch("HealClientRpc")]
		[HarmonyPostfix]
		public static void HealClientRpc_Prefix(PlayerControllerB __instance, bool __runOriginal)
		{
			if (__runOriginal)
			{
				LethalBotAI lethalBotAI = LethalBotManager.Instance.GetLethalBotAI(__instance);
				if ((Object)(object)lethalBotAI != (Object)null)
				{
					Plugin.LogDebug($"HealClientRpc called from game code on LOCAL client #{((NetworkBehaviour)lethalBotAI).NetworkManager.LocalClientId}, lethalBot object: Bot #{lethalBotAI.BotId}");
					__instance.playerBodyAnimator.SetBool("Limp", false);
				}
			}
		}

		[HarmonyPatch("KillPlayer")]
		[HarmonyPrefix]
		[HarmonyPriority(0)]
		private static bool KillPlayer_PreFix(PlayerControllerB __instance, bool __runOriginal, Vector3 bodyVelocity, bool spawnBody = true, CauseOfDeath causeOfDeath = 0, int deathAnimation = 0, Vector3 positionOffset = default(Vector3), bool setOverrideDropItems = false)
		{
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			if (!__runOriginal)
			{
				return true;
			}
			LethalBotAI lethalBotAI = LethalBotManager.Instance.GetLethalBotAI(__instance);
			if ((Object)(object)lethalBotAI != (Object)null)
			{
				Plugin.LogDebug($"SyncKillLethalBot called from game code on LOCAL client #{((NetworkBehaviour)lethalBotAI).NetworkManager.LocalClientId}, Bot #{lethalBotAI.BotId}");
				lethalBotAI.KillLethalBot(bodyVelocity, spawnBody, causeOfDeath, deathAnimation, positionOffset, setOverrideDropItems);
				return true;
			}
			return true;
		}

		[HarmonyPatch("KillPlayerClientRpc")]
		[HarmonyPostfix]
		private static void KillPlayerClientRpc_Postfix(PlayerControllerB __instance, ref int playerId, ref bool spawnBody, ref Vector3 bodyVelocity, ref int causeOfDeath, ref int deathAnimation, ref Vector3 positionOffset, ref bool setOverrideDropItems)
		{
			LethalBotAI lethalBotAI = LethalBotManager.Instance.GetLethalBotAI(__instance);
			if ((Object)(object)lethalBotAI == (Object)null)
			{
				return;
			}
			if ((Object)(object)__instance.deadBody != (Object)null)
			{
				lethalBotAI.LethalBotIdentity.DeadBody = __instance.deadBody;
				GrabbableObject val = __instance.deadBody?.grabBodyObject;
				if ((Object)(object)val != (Object)null)
				{
					LethalBotAI.DictJustDroppedItems[val] = Time.realtimeSinceStartup;
				}
			}
			else if (spawnBody && !__instance.overrideDontSpawnBody)
			{
				Plugin.LogWarning("Bot " + __instance.playerUsername + " dead body was not spawned. This is probably a bug with another mod or the base game itself!");
			}
			lethalBotAI.NpcController.CurrentLethalBotPhysicsRegions.Clear();
			((EnemyAI)lethalBotAI).isEnemyDead = true;
			lethalBotAI.LethalBotIdentity.Hp = 0;
			lethalBotAI.SetAgent(enabled: false);
			if (lethalBotAI.State == null || lethalBotAI.State.GetAIState() != 0)
			{
				lethalBotAI.State = new BrainDeadState(lethalBotAI);
			}
		}

		[HarmonyPatch("SwitchToItemSlot")]
		[HarmonyPrefix]
		private static bool SwitchToItemSlot_Prefix(PlayerControllerB __instance, int slot, GrabbableObject fillSlotWithItem = null)
		{
			LethalBotAI lethalBotAI = LethalBotManager.Instance.GetLethalBotAI(__instance);
			if ((Object)(object)lethalBotAI != (Object)null)
			{
				lethalBotAI.SwitchToItemSlot(slot, fillSlotWithItem);
				return false;
			}
			return true;
		}

		[HarmonyPatch("DiscardHeldObject")]
		[HarmonyPrefix]
		private static bool DiscardHeldObject_Prefix(PlayerControllerB __instance, bool placeObject = false, NetworkObject parentObjectTo = null, Vector3 placePosition = default(Vector3), bool matchRotationOfParent = true)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			LethalBotAI lethalBotAI = LethalBotManager.Instance.GetLethalBotAI(__instance);
			if ((Object)(object)lethalBotAI != (Object)null)
			{
				lethalBotAI.DropItem(placeObject, parentObjectTo, placePosition, matchRotationOfParent);
				return false;
			}
			return true;
		}

		[HarmonyPatch("DestroyItemInSlot")]
		[HarmonyPrefix]
		private static bool DestroyItemInSlot_Prefix(PlayerControllerB __instance, int itemSlot)
		{
			LethalBotAI lethalBotAI = LethalBotManager.Instance.GetLethalBotAI(__instance);
			if ((Object)(object)lethalBotAI != (Object)null)
			{
				lethalBotAI.DestroyItemInSlot(itemSlot);
				return false;
			}
			return true;
		}

		[HarmonyPatch("DropAllHeldItems")]
		[HarmonyPrefix]
		private static bool DropAllHeldItems_Prefix(PlayerControllerB __instance, bool itemsFall = true, bool setInShip = false, bool setInElevator = false, Vector3 syncedPlayerPosition = default(Vector3), Vector3 syncedHeldObjectPosition = default(Vector3), Vector3 syncedHeldObjectRotation = default(Vector3), Vector3 syncedPlayerCamPosition = default(Vector3), Vector3 syncedPlayerCamRotation = default(Vector3))
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: 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_0021: Unknown result type (might be due to invalid IL or missing references)
			LethalBotAI lethalBotAI = LethalBotManager.Instance.GetLethalBotAI(__instance);
			if ((Object)(object)lethalBotAI != (Object)null)
			{
				lethalBotAI.DropAllHeldItems(itemsFall, setInShip, setInElevator, syncedPlayerPosition, syncedHeldObjectPosition, syncedHeldObjectRotation, syncedPlayerCamPosition, syncedPlayerCamRotation);
				return false;
			}
			return true;
		}

		[HarmonyPatch("DespawnHeldObject")]
		[HarmonyPrefix]
		public static bool DespawnHeldObject_Prefix(PlayerControllerB __instance)
		{
			LethalBotAI lethalBotAI = LethalBotManager.Instance.GetLethalBotAI(__instance);
			if ((Object)(object)lethalBotAI != (Object)null)
			{
				lethalBotAI.DespawnHeldObject();
				return false;
			}
			return true;
		}

		[HarmonyPatch("UpdateSpecialAnimationValue")]
		[HarmonyPrefix]
		private static bool UpdateSpecialAnimationValue_PreFix(PlayerControllerB __instance, bool specialAnimation, float timed, bool climbingLadder)
		{
			LethalBotAI lethalBotAI = LethalBotManager.Instance.GetLethalBotAI(__instance);
			if ((Object)(object)lethalBotAI != (Object)null)
			{
				lethalBotAI.UpdateLethalBotSpecialAnimationValue(specialAnimation, timed, climbingLadder);
				return false;
			}
			return true;
		}

		[HarmonyPatch("CancelSpecialTriggerAnimations")]
		[HarmonyPrefix]
		public static bool CancelSpecialTriggerAnimations_Prefix(PlayerControllerB __instance)
		{
			LethalBotAI lethalBotAI = LethalBotManager.Instance.GetLethalBotAI(__instance);
			if ((Object)(object)lethalBotAI == (Object)null)
			{
				return true;
			}
			if (__instance.inTerminalMenu)
			{
				lethalBotAI.LeaveTerminal();
			}
			else if ((Object)(object)__instance.currentTriggerInAnimationWith != (Object)null)
			{
				__instance.currentTriggerInAnimationWith.StopSpecialAnimation();
			}
			return false;
		}

		[HarmonyPatch("IncreaseFearLevelOverTime")]
		[HarmonyPrefix]
		private static bool IncreaseFearLevelOverTime_PreFix(PlayerControllerB __instance, float amountMultiplier = 1f, float cap = 1f)
		{
			LethalBotAI lethalBotAIIfLocalIsOwner = LethalBotManager.Instance.GetLethalBotAIIfLocalIsOwner(__instance);
			if ((Object)(object)lethalBotAIIfLocalIsOwner != (Object)null)
			{
				lethalBotAIIfLocalIsOwner.FearLevelIncreasing.Value = true;
				if (!(lethalBotAIIfLocalIsOwner.FearLevel.Value > cap))
				{
					NetworkVariable<float> fearLevel = lethalBotAIIfLocalIsOwner.FearLevel;
					fearLevel.Value += Time.deltaTime * amountMultiplier;
					if (lethalBotAIIfLocalIsOwner.FearLevel.Value > 0.6f && __instance.timeSinceFearLevelUp > 8f)
					{
						__instance.timeSinceFearLevelUp = 0f;
					}
				}
				return false;
			}
			return true;
		}

		[HarmonyPatch("JumpToFearLevel")]
		[HarmonyPrefix]
		private static bool JumpToFearLevel_PreFix(PlayerControllerB __instance, float targetFearLevel, bool onlyGoUp = true)
		{
			LethalBotAI lethalBotAIIfLocalIsOwner = LethalBotManager.Instance.GetLethalBotAIIfLocalIsOwner(__instance);
			if ((Object)(object)lethalBotAIIfLocalIsOwner != (Object)null)
			{
				if (!onlyGoUp || !((double)(targetFearLevel - lethalBotAIIfLocalIsOwner.FearLevel.Value) < 0.05))
				{
					lethalBotAIIfLocalIsOwner.FearLevel.Value = targetFearLevel;
					lethalBotAIIfLocalIsOwner.FearLevelIncreasing.Value = true;
					if (__instance.timeSinceFearLevelUp > 8f)
					{
						__instance.timeSinceFearLevelUp = 0f;
					}
				}
				return false;
			}
			return true;
		}

		[HarmonyPatch("PerformEmote")]
		[HarmonyPrefix]
		private static bool PerformEmote_PreFix(PlayerControllerB __instance, int emoteID)
		{
			LethalBotAI lethalBotAI = LethalBotManager.Instance.GetLethalBotAI(__instance);
			if ((Object)(object)lethalBotAI == (Object)null)
			{
				return true;
			}
			if (!CheckConditionsForEmote_ReversePatch(__instance))
			{
				return false;
			}
			__instance.performingEmote = true;
			__instance.playerBodyAnimator.SetInteger("emoteNumber", emoteID);
			lethalBotAI.StartPerformingEmoteLethalBotServerRpc(emoteID);
			return false;
		}

		[HarmonyPatch("StartPerformingEmoteServerRpc")]
		[HarmonyPrefix]
		private static bool StartPerformingEmoteServerRpc_PreFix(PlayerControllerB __instance)
		{
			LethalBotAI lethalBotAI = LethalBotManager.Instance.GetLethalBotAI(__instance);
			if ((Object)(object)lethalBotAI == (Object)null)
			{
				return true;
			}
			lethalBotAI.StartPerformingEmoteLethalBotServerRpc(__instance.playerBodyAnimator.GetInteger("emoteNumber"));
			return false;
		}

		[HarmonyPatch("ConnectClientToPlayerObject")]
		[HarmonyPrefix]
		private static bool ConnectClientToPlayerObject_PreFix(PlayerControllerB __instance)
		{
			LethalBotAI lethalBotAI = LethalBotManager.Instance.GetLethalBotAI(__instance);
			if ((Object)(object)lethalBotAI != (Object)null)
			{
				return false;
			}
			return true;
		}

		[HarmonyPatch("SpawnPlayerAnimation")]
		[HarmonyPrefix]
		private static bool SpawnPlayerAnimation_PreFix(PlayerControllerB __instance)
		{
			LethalBotAI lethalBotAI = LethalBotManager.Instance.GetLethalBotAI(__instance);
			if ((Object)(object)lethalBotAI == (Object)null)
			{
				return true;
			}
			if (lethalBotAI.spawnAnimationCoroutine != null)
			{
				((MonoBehaviour)lethalBotAI).StopCoroutine(lethalBotAI.spawnAnimationCoroutine);
			}
			lethalBotAI.spawnAnimationCoroutine = lethalBotAI.BeginLethalBotSpawnAnimation(EnumSpawnAnimation.OnlyPlayerSpawnAnimation);
			return false;
		}

		[HarmonyPatch("TeleportPlayer")]
		[HarmonyPrefix]
		private static bool TeleportPlayer_PreFix(PlayerControllerB __instance, Vector3 pos, ref bool ___teleportingThisFrame, bool withRotation = false, float rot = 0f, bool allowInteractTrigger = false)
		{
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			LethalBotAI lethalBotAI = LethalBotManager.Instance.GetLethalBotAI(__instance);
			if ((Object)(object)lethalBotAI != (Object)null)
			{
				((UnityEvent<PlayerControllerB>)(object)StartOfRound.Instance.playerTeleportedEvent).Invoke(__instance);
				___teleportingThisFrame = true;
				lethalBotAI.NpcController.TeleportingThisFrame = true;
				__instance.teleportedLastFrame = true;
				bool withRotation2 = withRotation;
				bool allowInteractTrigger2 = allowInteractTrigger;
				lethalBotAI.TeleportLethalBot(pos, null, null, withRotation2, rot, allowInteractTrigger2);
				return false;
			}
			return true;
		}

		[HarmonyPatch("PlayFootstepServer")]
		[HarmonyPrefix]
		private static bool PlayFootstepServer_PreFix(PlayerControllerB __instance)
		{
			LethalBotAI lethalBotAI = LethalBotManager.Instance.GetLethalBotAI(__instance);
			if ((Object)(object)lethalBotAI != (Object)null)
			{
				lethalBotAI.NpcController.PlayFootstep(isServer: true);
				return false;
			}
			return true;
		}

		[HarmonyPatch("PlayFootstepLocal")]
		[HarmonyPrefix]
		private static bool PlayFootstepLocal_PreFix(PlayerControllerB __instance)
		{
			LethalBotAI lethalBotAI = LethalBotManager.Instance.GetLethalBotAI(__instance);
			if ((Object)(object)lethalBotAI != (Object)null)
			{
				lethalBotAI.NpcController.PlayFootstep(isServer: false);
				return false;
			}
			return true;
		}

		[HarmonyPatch("UpdatePlayerPhysicsParentServerRpc")]
		[HarmonyReversePatch(/*Could not decode attribute arguments.*/)]
		[HarmonyPriority(0)]
		public static void UpdatePlayerPhysicsParentServerRpc_ReversePatch(object instance, Vector3 newPos, NetworkObjectReference setPhysicsParent, bool isOverride, bool inElevator, bool isInShip)
		{
			throw new NotImplementedException("Stub LethalBot.Patches.NpcPatches.PlayerControllerBPatch.UpdatePlayerPhysicsParentServerRpc_ReversePatch");
		}

		[HarmonyPatch("RemovePlayerPhysicsParentServerRpc")]
		[HarmonyReversePatch(/*Could not decode attribute arguments.*/)]
		[HarmonyPriority(0)]
		public static void RemovePlayerPhysicsParentServerRpc_ReversePatch(object instance, Vector3 newPos, bool removeOverride, bool removeBoth, bool inElevator, bool isInShip)
		{
			throw new NotImplementedException("Stub LethalBot.Patches.NpcPatches.PlayerControllerBPatch.RemovePlayerPhysicsParentServerRpc_ReversePatch");
		}

		[HarmonyPatch("DropHeldItem")]
		[HarmonyReversePatch(/*Could not decode attribute arguments.*/)]
		[HarmonyPriority(0)]
		public static void DropHeldItem_ReversePatch(object instance, GrabbableObject dropItem, bool itemsFall, bool disconnecting, Vector3 syncedPlayerPosition, Vector3 syncedHeldObjectPosition, Vector3 syncedHeldObjectRotation, Vector3 syncedPlayerCamPosition, Vector3 syncedPlayerCamRotation, bool setInShip, bool setInElevator)
		{
			throw new NotImplementedException("Stub LethalBot.Patches.NpcPatches.PlayerControllerBPatch.DropHeldItem_ReversePatch");
		}

		[HarmonyPatch("PlayJumpAudio")]
		[HarmonyReversePatch(/*Could not decode attribute arguments.*/)]
		[HarmonyPriority(0)]
		public static void PlayJumpAudio_ReversePatch(object instance)
		{
			throw new NotImplementedException("Stub LethalBot.Patches.NpcPatches.PlayerControllerBPatch.PlayJumpAudio_ReversePatch");
		}

		[HarmonyPatch("PlayerHitGroundEffects")]
		[HarmonyReversePatch(/*Could not decode attribute arguments.*/)]
		[HarmonyPriority(0)]
		public static void PlayerHitGroundEffects_ReversePatch(object instance)
		{
			throw new NotImplementedException("Stub LethalBot.Patches.NpcPatches.PlayerControllerBPatch.PlayerHitGroundEffects_ReversePatch");
		}

		[HarmonyPatch("CheckConditionsForEmote")]
		[HarmonyReversePatch(/*Could not decode attribute arguments.*/)]
		[HarmonyPriority(0)]
		public static bool CheckConditionsForEmote_ReversePatch(object instance)
		{
			throw new NotImplementedException("Stub LethalBot.Patches.NpcPatches.PlayerControllerBPatch.PlayerControllerBPatchCheckConditionsForEmote_ReversePatch");
		}

		[HarmonyPatch("OnDisable")]
		[HarmonyReversePatch(/*Could not decode attribute arguments.*/)]
		[HarmonyPriority(0)]
		public static void OnDisable_ReversePatch(object instance)
		{
			throw new NotImplementedException("Stub LethalBot.Patches.NpcPatches.OnDisable_ReversePatch");
		}

		[HarmonyPatch("InteractTriggerUseConditionsMet")]
		[HarmonyReversePatch(/*Could not decode attribute arguments.*/)]
		[HarmonyPriority(0)]
		public static bool InteractTriggerUseConditionsMet_ReversePatch(object instance)
		{
			throw new NotImplementedException("Stub LethalBot.Patches.NpcPatches.InteractTriggerUseConditionsMet_ReversePatch");
		}

		[HarmonyPatch("IsInSpecialAnimationClientRpc")]
		[HarmonyReversePatch(/*Could not decode attribute arguments.*/)]
		[HarmonyPriority(0)]
		public static void IsInSpecialAnimationClientRpc_ReversePatch(object instance, bool specialAnimation, float timed, bool climbingLadder)
		{
			throw new NotImplementedException("Stub LethalBot.Patches.NpcPatches.PlayerControllerBPatch.IsInSpecialAnimationClientRpc_ReversePatch");
		}

		[HarmonyPatch("SetSpecialGrabAnimationBool")]
		[HarmonyReversePatch(/*Could not decode attribute arguments.*/)]
		[HarmonyPriority(0)]
		public static void SetSpecialGrabAnimationBool_ReversePatch(object instance, bool setTrue, GrabbableObject currentItem)
		{
			throw new NotImplementedException("Stub LethalBot.Patches.NpcPatches.SetSpecialGrabAnimationBool_ReversePatch");
		}

		[HarmonyPatch("SetNightVisionEnabled")]
		[HarmonyReversePatch(/*Could not decode attribute arguments.*/)]
		[HarmonyPriority(0)]
		public static void SetNightVisionEnabled_ReversePatch(object instance, bool isNotLocalClient)
		{
			throw new NotImplementedException("Stub LethalBot.Patches.NpcPatches.SetNightVisionEnabled_ReversePatch");
		}

		[HarmonyPatch("SetPlayerSanityLevel")]
		[HarmonyReversePatch(/*Could not decode attribute arguments.*/)]
		[HarmonyPriority(0)]
		public static void SetPlayerSanityLevel_ReversePatch(object instance)
		{
			throw new NotImplementedException("Stub LethalBot.Patches.NpcPatches.SetPlayerSanityLevel_ReversePatch");
		}

		[HarmonyPatch("Crouch")]
		[HarmonyTranspiler]
		public static IEnumerable<CodeInstruction> Crouch_Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator generator)
		{
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Expected O, but got Unknown
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Expected O, but got Unknown
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Expected O, but got Unknown
			bool flag = false;
			int num = 0;
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			MethodInfo methodInfo = AccessTools.PropertyGetter(typeof(StartOfRound), "Instance");
			FieldInfo fieldInfo = AccessTools.Field(typeof(StartOfRound), "timeAtMakingLastPersonalMovement");
			MethodInfo methodInfo2 = AccessTools.PropertyGetter(typeof(Time), "realtimeSinceStartup");
			for (int i = 0; i < list.Count - 2; i++)
			{
				if (CodeInstructionExtensions.Calls(list[i], methodInfo) && CodeInstructionExtensions.Calls(list[i + 1], methodInfo2) && CodeInstructionExtensions.StoresField(list[i + 2], fieldInfo))
				{
					Label label = generator.DefineLabel();
					List<CodeInstruction> list2 = new List<CodeInstruction>
					{
						new CodeInstruction(OpCodes.Ldarg_0, (object)null),
						new CodeInstruction(OpCodes.Call, (object)PatchesUtil.IsPlayerLocalMethod),
						new CodeInstruction(OpCodes.Brfalse, (object)label)
					};
					list[i + 3].labels.Add(label);
					list.InsertRange(i, list2);
					i += list2.Count;
					flag = true;
					num++;
				}
			}
			if (!flag)
			{
				Plugin.LogError("LethalBots.Patches.NpcPatches.PlayerControllerBPatch.Crouch_Transpiler could not check if player local for Crouch");
			}
			else
			{
				Plugin.LogDebug($"Patched out timeAtMakingLastPersonalMovement for bots in Crouch {num} times!");
			}
			return list.AsEnumerable();
		}

		[HarmonyPatch("DamagePlayer")]
		[HarmonyTranspiler]
		public static IEnumerable<CodeInstruction> DamagePlayer_Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator generator)
		{
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Expected O, but got Unknown
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Expected O, but got Unknown
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Expected O, but got Unknown
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Expected O, but got Unknown
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			Label label = generator.DefineLabel();
			list[0].labels.Add(label);
			List<CodeInstruction> collection = new List<CodeInstruction>
			{
				new CodeInstruction(OpCodes.Ldarg_0, (object)null),
				new CodeInstruction(OpCodes.Call, (object)PatchesUtil.IsPlayerLethalBotMethod),
				new CodeInstruction(OpCodes.Brfalse, (object)label),
				new CodeInstruction(OpCodes.Ret, (object)null)
			};
			list.InsertRange(0, collection);
			return list.AsEnumerable();
		}

		[HarmonyPatch("SendNewPlayerValuesClientRpc")]
		[HarmonyPostfix]
		private static void SendNewPlayerValuesClientRpc_PostFix(PlayerControllerB __instance)
		{
			if ((Object)(object)LethalBotManager.Instance == (Object)null)
			{
				return;
			}
			LethalBotAI[] lethalBotAIs = LethalBotManager.Instance.GetLethalBotAIs();
			foreach (LethalBotAI lethalBotAI in lethalBotAIs)
			{
				PlayerControllerB val = lethalBotAI.NpcController?.Npc;
				if ((Object)(object)val != (Object)null && lethalBotAI.LethalBotIdentity != null)
				{
					string text = (val.playerUsername = lethalBotAI.LethalBotIdentity.Name);
					((TMP_Text)val.usernameBillboardText).text = text;
					val.quickMenuManager.AddUserToPlayerList(0uL, text, (int)val.playerClientId);
					StartOfRound.Instance.mapScreen.radarTargets[(int)val.playerClientId].name = text;
				}
			}
		}

		[HarmonyPatch("KillPlayer")]
		[HarmonyPostfix]
		private static void KillPlayer_PostFix(PlayerControllerB __instance)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			if (((NetworkBehaviour)__instance).IsOwner && __instance.isPlayerDead && __instance.AllowPlayerDeath())
			{
				GroupManager.Instance.RemoveFromCurrentGroupAndSync(__instance);
				LethalBotManager.Instance.RemovePlayerFromLootTransferListAndSync(NetworkBehaviourReference.op_Implicit((NetworkBehaviour)(object)__instance));
			}
		}

		[HarmonyPatch("SetHoverTipAndCurrentInteractTrigger")]
		[HarmonyPostfix]
		private static void SetHoverTipAndCurrentInteractTrigger_PostFix(ref PlayerControllerB __instance, ref Ray ___interactRay, int ___playerMask, int ___interactableObjectsMask, ref RaycastHit ___hit)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			___interactRay = new Ray(((Component)__instance.gameplayCamera).transform.position, ((Component)__instance.gameplayCamera).transform.forward);
			if (Physics.Raycast(___interactRay, ref ___hit, __instance.grabDistance, ___interactableObjectsMask) && ((Component)((RaycastHit)(ref ___hit)).collider).gameObject.layer != 8 && ((Component)((RaycastHit)(ref ___hit)).collider).gameObject.layer != 30 && ((Component)((RaycastHit)(ref ___hit)).collider).tag == "PhysicsProp")
			{
				RagdollGrabbableObject component = ((Component)((RaycastHit)(ref ___hit)).collider).gameObject.GetComponent<RagdollGrabbableObject>();
				if ((Object)(object)component == (Object)null)
				{
					return;
				}
				if (component.bodyID == -2)
				{
					((TMP_Text)__instance.cursorTip).text = string.Empty;
					((Behaviour)__instance.cursorIcon).enabled = false;
					return;
				}
			}
			RaycastHit[] array = (RaycastHit[])(object)new RaycastHit[3];
			int num = Physics.RaycastNonAlloc(___interactRay, array, __instance.grabDistance, ___playerMask);
			for (int i = 0; i < num; i++)
			{
				RaycastHit val = array[i];
				if ((Object)(object)((RaycastHit)(ref val)).collider == (Object)null || ((Component)((RaycastHit)(ref val)).collider).tag != "Player")
				{
					continue;
				}
				PlayerControllerB component2 = ((Component)((RaycastHit)(ref val)).collider).gameObject.GetComponent<PlayerControllerB>();
				if ((Object)(object)component2 == (Object)null)
				{
					continue;
				}
				LethalBotAI lethalBotAI = LethalBotManager.Instance.GetLethalBotAI(component2);
				if ((Object)(object)lethalBotAI == (Object)null)
				{
					continue;
				}
				if (!Plugin.Config.DisableNameBillBoards.Value)
				{
					lethalBotAI.NpcController.Npc.ShowNameBillboard();
				}
				if (!lethalBotAI.IsSpawningAnimationRunning())
				{
					StringBuilder stringBuilder = new StringBuilder();
					if (lethalBotAI.HasSomethingInInventory())
					{
						stringBuilder.Append($"Drop your item : [{InputManager.Instance.GetKeyAction(Plugin.InputActionsInstance.DropItem)}]").AppendLine();
					}
					EnumAIStates aIState = lethalBotAI.State.GetAIState();
					if (((NetworkBehaviour)lethalBotAI).OwnerClientId != __instance.actualClientId || !lethalBotAI.IsFollowingLocalPlayer())
					{
						stringBuilder.Append($"Follow me: [{InputManager.Instance.GetKeyAction(Plugin.InputActionsInstance.LeadBot)}]").AppendLine();
					}
					else if (aIState != EnumAIStates.SearchingForScrap)
					{
						stringBuilder.Append($"Lead the way: [{InputManager.Instance.GetKeyAction(Plugin.InputActionsInstance.LeadBot)}]").AppendLine();
					}
					if (component2.currentSuitID != __instance.currentSuitID)
					{
						stringBuilder.Append($"Change suit : [{InputManager.Instance.GetKeyAction(Plugin.InputActionsInstance.ChangeSuitBot)}]");
					}
					((TMP_Text)__instance.cursorTip).text = stringBuilder.ToString();
					break;
				}
			}
		}
	}
}
namespace LethalBots.Patches.ModPatches.Zaprillator
{
	public class RevivablePlayerPatch
	{
		public static bool StopShockingWithGun_Prefix(RagdollGrabbableObject ____ragdoll, ref bool ____bodyShocked, ref GrabbableObject ____shockedBy, float ____batteryLevel)
		{
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)____ragdoll == (Object)null)
			{
				return true;
			}
			if (!____bodyShocked)
			{
				return false;
			}
			if ((Object)(object)____shockedBy == (Object)null || !((NetworkBehaviour)____shockedBy).IsOwner)
			{
				return false;
			}
			string headerText = ((Component)____ragdoll.ragdoll).gameObject.GetComponentInChildren<ScanNodeProperties>().headerText;
			LethalBotIdentity lethalBotIdentity = IdentityManager.Instance.FindIdentityFromBodyName(headerText);
			if (lethalBotIdentity == null)
			{
				return true;
			}
			if (lethalBotIdentity.Alive)
			{
				Plugin.LogError("Zaprillator with LethalBot: error when trying to revive bot \"" + lethalBotIdentity.Name + "\", bot is already alive! do nothing more");
				return false;
			}
			____bodyShocked = false;
			RoundManager.Instance.FlickerLights(false, false);
			int hp = LethalBotManager.Instance.MaxHealthPercent(Mathf.RoundToInt(____batteryLevel * 100f), lethalBotIdentity.HpMax);
			____shockedBy.UseUpBatteries();
			____shockedBy.SyncBatteryServerRpc(0);
			____shockedBy = null;
			LethalBotManager.Instance.SpawnThisLethalBotServerRpc(lethalBotIdentity.IdIdentity, new SpawnLethalBotParamsNetworkSerializable
			{
				ShouldDestroyDeadBody = true,
				ResetBodyBlood = true,
				Hp = hp,
				enumSpawnAnimation = EnumSpawnAnimation.OnlyPlayerSpawnAnimation,
				SpawnPosition = ((Component)____ragdoll.ragdoll).transform.position,
				YRot = 0f,
				IsOutside = !GameNetworkManager.Instance.localPlayerController.isInsideFactory,
				IndexNextPlayerObject = (int)____ragdoll.ragdoll.playerScript.playerClientId
			});
			StartOfRound instance = StartOfRound.Instance;
			instance.livingPlayers++;
			return false;
		}
	}
}
namespace LethalBots.Patches.ModPatches.UsualScrap
{
	[HarmonyPatch(typeof(DefibrillatorScript))]
	public class DefibrillatorScriptPatch
	{
		[HarmonyPatch("RevivePlayer")]
		[HarmonyPrefix]
		private static bool RevivePlayer_Prefix(DefibrillatorScript __instance, ref int PlayerID, ref Vector3 SpawnPosition, ref bool ___UsesLimited, ref int ___useLimit, ref Renderer[] ___displayRenderers)
		{
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			if (PlayerID < 0)
			{
				Plugin.LogInfo("US - No player inital id? returning..");
				return true;
			}
			LethalBotAI lethalBotAI = LethalBotManager.Instance.GetLethalBotAI(PlayerID);
			if ((Object)(object)lethalBotAI == (Object)null)
			{
				return true;
			}
			PlayerControllerB val = RoundManager.Instance.playersManager.allPlayerScripts[PlayerID];
			if (!val.isPlayerDead)
			{
				return false;
			}
			if (!((NetworkBehaviour)__instance).IsServer)
			{
				return false;
			}
			LethalBotIdentity lethalBotIdentity = lethalBotAI.LethalBotIdentity;
			LethalBotManager.Instance.SpawnThisLethalBotServerRpc(lethalBotIdentity.IdIdentity, new SpawnLethalBotParamsNetworkSerializable
			{
				ShouldDestroyDeadBody = true,
				ResetBodyBlood = true,
				Hp = 5,
				enumSpawnAnimation = EnumSpawnAnimation.OnlyPlayerSpawnAnimation,
				SpawnPosition = SpawnPosition,
				YRot = 0f,
				IsOutside = (SpawnPosition.y >= -80f),
				IndexNextPlayerObject = PlayerID
			});
			StartOfRound instance = StartOfRound.Instance;
			instance.livingPlayers++;
			if (___UsesLimited && ___useLimit > 0)
			{
				___useLimit--;
				if (___useLimit <= 0)
				{
					Renderer[] array = ___displayRenderers;
					foreach (Renderer val2 in array)
					{
						val2.material.SetColor("_EmissiveColor", Color.red);
					}
				}
			}
			return false;
		}
	}
}
namespace LethalBots.Patches.ModPatches.TooManyEmotes
{
	[HarmonyPatch(typeof(EmoteControllerPlayer))]
	public class EmoteControllerPlayerPatch
	{
		[HarmonyPatch("PerformEmote", new Type[]
		{
			typeof(UnlockableEmote),
			typeof(int),
			typeof(bool)
		})]
		[HarmonyTranspiler]
		public static IEnumerable<CodeInstruction> PerformEmote_Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator generator)
		{
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: 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
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Expected O, but got Unknown
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Expected O, but got Unknown
			int num = -1;
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			for (int i = 0; i < list.Count - 2; i++)
			{
				if (((object)list[i]).ToString().StartsWith("call static void TooManyEmotes.Patches.ThirdPersonEmoteController::OnStartCustomEmoteLocal()") && ((object)list[i + 2]).ToString().StartsWith("ldarg.0 NULL"))
				{
					num = i;
					break;
				}
			}
			if (num > -1)
			{
				Label label = generator.DefineLabel();
				list[num + 2].labels.Add(label);
				CodeInstruction item = new CodeInstruction(list[2].opcode, list[2].operand);
				List<CodeInstruction> collection = new List<CodeInstruction>
				{
					new CodeInstruction(OpCodes.Ldarg_0, (object)null),
					item,
					new CodeInstruction(OpCodes.Call, (object)PatchesUtil.IsPlayerLethalBotMethod),
					new CodeInstruction(OpCodes.Brtrue, (object)label)
				};
				list.InsertRange(num, collection);
				num = -1;
			}
			else
			{
				Plugin.LogError("LethalBot.Patches.ModPatches.TooManyEmotes.EmoteControllerPlayerPatch.PerformEmote_Transpiler could not not do OnStartCustomEmoteLocal when bot.");
			}
			return list.AsEnumerable();
		}

		[HarmonyPatch("StopPerformingEmote")]
		[HarmonyTranspiler]
		public static IEnumerable<CodeInstruction> StopPerformingEmote_Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator generator)
		{
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: 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
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Expected O, but got Unknown
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Expected O, but got Unknown
			int num = -1;
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			for (int i = 0; i < list.Count - 2; i++)
			{
				if (((object)list[i]).ToString().StartsWith("call static void TooManyEmotes.Patches.ThirdPersonEmoteController::OnStopCustomEmoteLocal()") && ((object)list[i + 2]).ToString().StartsWith("ldarg.0 NULL"))
				{
					num = i;
					break;
				}
			}
			if (num > -1)
			{
				Label label = generator.DefineLabel();
				list[num + 2].labels.Add(label);
				CodeInstruction item = new CodeInstruction(list[2].opcode, list[2].operand);
				List<CodeInstruction> collection = new List<CodeInstruction>
				{
					new CodeInstruction(OpCodes.Ldarg_0, (object)null),
					item,
					new CodeInstruction(OpCodes.Call, (object)PatchesUtil.IsPlayerLethalBotMethod),
					new CodeInstruction(OpCodes.Brtrue, (object)label)
				};
				list.InsertRange(num, collection);
				num = -1;
			}
			else
			{
				Plugin.LogError("LethalBot.Patches.ModPatches.TooManyEmotes.EmoteControllerPlayerPatch.StopPerformingEmote_Transpiler could not not do OnStopCustomEmoteLocal when bot.");
			}
			return list.AsEnumerable();
		}
	}
	[HarmonyPatch(typeof(ThirdPersonEmoteController))]
	public class ThirdPersonEmoteControllerPatch
	{
		[HarmonyPatch("UseFreeCamWhileEmoting")]
		[HarmonyPrefix]
		public static bool UseFreeCamWhileEmoting_Prefix(PlayerControllerB __0)
		{
			if (LethalBotManager.Instance.IsPlayerLethalBot(__0))
			{
				return false;
			}
			return true;
		}

		[HarmonyPatch("InitLocalPlayerController")]
		[HarmonyPrefix]
		public static bool InitLocalPlayerController_Prefix(PlayerControllerB __0)
		{
			if (LethalBotManager.Instance.IsPlayerLethalBot(__0))
			{
				return false;
			}
			return true;
		}

		[HarmonyPatch("OnPlayerSpawn")]
		[HarmonyPrefix]
		public static bool OnPlayerSpawn_Prefix(PlayerControllerB __0)
		{
			if (LethalBotManager.Instance.IsPlayerLethalBot(__0))
			{
				return false;
			}
			return true;
		}
	}
}
namespace LethalBots.Patches.ModPatches.ShowCapacity
{
	public class ShowCapacityPatch
	{
		private static GameObject? capacityMeter;

		public static bool Update_PostFix_Prefix(bool __0, GrabbableObject __1, bool __2)
		{
			Update_ShowCapacityPatch(__0, __1, __2);
			return false;
		}

		private static void Update_ShowCapacityPatch(bool isHoldingObject, GrabbableObject currentlyHeldObjectServer, bool isCameraDisabled)
		{
			if ((Object)(object)capacityMeter == (Object)null)
			{
				GameObject val = GameObject.Find("CapacityMeter");
				if ((Object)(object)val != (Object)null)
				{
					capacityMeter = val;
					capacityMeter.SetActive(false);
				}
			}
			if ((Object)(object)capacityMeter == (Object)null)
			{
				return;
			}
			GrabbableObject val2 = StartOfRound.Instance?.localPlayerController?.currentlyHeldObjectServer;
			if ((Object)(object)val2 == (Object)null)
			{
				capacityMeter.SetActive(false);
			}
			else
			{
				if (isCameraDisabled || !isHoldingObject || (Object)(object)currentlyHeldObjectServer == (Object)null)
				{
					return;
				}
				if ((Object)(object)val2 != (Object)(object)currentlyHeldObjectServer)
				{
					if ((Object)(object)val2 == (Object)null)
					{
						capacityMeter.SetActive(false);
					}
					return;
				}
				SprayPaintItem component = ((Component)currentlyHeldObjectServer).GetComponent<SprayPaintItem>();
				if ((Object)(object)component != (Object)null)
				{
					FieldInfo field = typeof(SprayPaintItem).GetField("sprayCanTank", BindingFlags.Instance | BindingFlags.NonPublic);
					if (field != null)
					{
						float num = (float)field.GetValue(component);
						capacityMeter.GetComponent<Image>().fillAmount = num / 1.3f;
					}
					capacityMeter.SetActive(true);
					return;
				}
				TetraChemicalItem component2 = ((Component)currentlyHeldObjectServer).GetComponent<TetraChemicalItem>();
				if ((Object)(object)component2 != (Object)null)
				{
					FieldInfo field2 = typeof(TetraChemicalItem).GetField("fuel", BindingFlags.Instance | BindingFlags.NonPublic);
					if (field2 != null)
					{
						float num2 = (float)field2.GetValue(component2);
						capacityMeter.GetComponent<Image>().fillAmount = num2 / 1.3f;
					}
					capacityMeter.SetActive(true);
				}
				else
				{
					capacityMeter.SetActive(false);
				}
			}
		}
	}
}
namespace LethalBots.Patches.ModPatches.ReviveCompany
{
	[HarmonyPatch(typeof(GeneralUtil))]
	public class ReviveCompanyGeneralUtilPatch
	{
		[HarmonyPatch("RevivePlayer")]
		[HarmonyPrefix]
		private static bool RevivePlayer_Prefix(int playerId)
		{
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_015d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			if (!LethalBotManager.Instance.IsPlayerLethalBot(playerId))
			{
				return true;
			}
			GrabbableObject obj = StartOfRound.Instance.allPlayerScripts[playerId]?.deadBody?.grabBodyObject;
			RagdollGrabbableObject val = (RagdollGrabbableObject)(object)((obj is RagdollGrabbableObject) ? obj : null);
			if ((Object)(object)val == (Object)null)
			{
				Plugin.LogError("Revive company with LethalBot: error when trying to revive bot, could not find body.");
				return false;
			}
			string headerText = ((Component)val.ragdoll).gameObject.GetComponentInChildren<ScanNodeProperties>().headerText;
			LethalBotIdentity lethalBotIdentity = IdentityManager.Instance.FindIdentityFromBodyName(headerText);
			if (lethalBotIdentity == null)
			{
				return true;
			}
			if (lethalBotIdentity.Alive)
			{
				Plugin.LogError("Revive company with LethalBot: error when trying to revive bot \"" + lethalBotIdentity.Name + "\", bot is already alive! do nothing more");
				return false;
			}
			LethalBotManager.Instance.UpdateReviveCompanyRemainingRevivesServerRpc(lethalBotIdentity.Name);
			PlayerControllerB closestAlivePlayer = GeneralUtil.GetClosestAlivePlayer(((Component)val).transform.position);
			Vector3 position = ((Component)val).transform.position;
			Quaternion rotation = ((Component)closestAlivePlayer).transform.rotation;
			float y = ((Quaternion)(ref rotation)).eulerAngles.y;
			if (Vector3.Distance(position, ((Component)closestAlivePlayer).transform.position) > 7f)
			{
				position = ((Component)closestAlivePlayer).transform.position;
			}
			bool isInsideFactory = closestAlivePlayer.isInsideFactory;
			Plugin.LogDebug("Reviving bot " + lethalBotIdentity.Name);
			LethalBotManager.Instance.SpawnThisLethalBotServerRpc(lethalBotIdentity.IdIdentity, new SpawnLethalBotParamsNetworkSerializable
			{
				Hp = ConfigVariables.ReviveToHealth,
				ShouldDestroyDeadBody = true,
				ResetBodyBlood = true,
				enumSpawnAnimation = EnumSpawnAnimation.OnlyPlayerSpawnAnimation,
				SpawnPosition = position,
				YRot = y,
				IsOutside = !isInsideFactory,
				IndexNextPlayerObject = (int)val.ragdoll.playerScript.playerClientId
			});
			StartOfRound instance = StartOfRound.Instance;
			instance.livingPlayers++;
			return false;
		}
	}
}
namespace LethalBots.Patches.ModPatches.Peepers
{
	[HarmonyPatch(typeof(PeeperAttachHitbox))]
	public class PeeperAttachHitboxPatch
	{
		[HarmonyPatch("OnTriggerEnter")]
		[HarmonyPostfix]
		public static void OnTriggerEnter_Postfix(PeeperAttachHitbox __instance, Collider other)
		{
			if (((Component)other).CompareTag("Player"))
			{
				PlayerControllerB component = ((Component)other).gameObject.GetComponent<PlayerControllerB>();
				if ((Object)(object)component != (Object)null && LethalBotManager.Instance.IsPlayerLethalBot(component))
				{
					__instance.mainScript.AttachToPlayerServerRpc(component.playerClientId);
				}
			}
			else if (other is BoxCollider)
			{
				PlayerControllerB componentInParent = ((Component)other).gameObject.GetComponentInParent<PlayerControllerB>();
				if ((Object)(object)componentInParent != (Object)null && LethalBotManager.Instance.IsPlayerLethalBot(componentInParent))
				{
					__instance.mainScript.AttachToPlayerServerRpc(componentInParent.playerClientId);
				}
			}
		}
	}
}
namespace LethalBots.Patches.ModPatches.MoreEmotes
{
	[HarmonyPatch(typeof(EmotePatch))]
	public class MoreEmotesPatch
	{
		[HarmonyPatch("StartPostfix")]
		[HarmonyPrefix]
		public static bool StartPostfix_Prefix(PlayerControllerB __0)
		{
			if ((Object)(object)((Component)__0).gameObject.GetComponent<CustomAnimationObjects>() != (Object)null)
			{
				return false;
			}
			return true;
		}

		[HarmonyPatch("UpdatePostfix")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> UpdatePostfix_Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator generator)
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Expected O, but got Unknown
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Expected O, but got Unknown
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Expected O, but got Unknown
			int num = 0;
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			Label label = generator.DefineLabel();
			list[num + 25].labels.Add(label);
			List<CodeInstruction> collection = new List<CodeInstruction>
			{
				new CodeInstruction(OpCodes.Ldarg_0, (object)null),
				new CodeInstruction(OpCodes.Call, (object)PatchesUtil.IsPlayerLethalBotOwnerLocalMethod),
				new CodeInstruction(OpCodes.Brtrue, (object)label)
			};
			list.InsertRange(num, collection);
			return list.AsEnumerable();
		}

		[HarmonyPatch("PerformEmotePrefix")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> PerformEmotePrefix_Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator generator)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Expected O, but got Unknown
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Expected O, but got Unknown
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Expected O, but got Unknown
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_012d: Expected O, but got Unknown
			//IL_013a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0144: Expected O, but got Unknown
			//IL_01db: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e5: Expected O, but got Unknown
			//IL_01f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0201: Expected O, but got Unknown
			//IL_020e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0218: Expected O, but got Unknown
			//IL_02dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e7: Expected O, but got Unknown
			//IL_0315: Unknown result type (might be due to invalid IL or missing references)
			//IL_031f: Expected O, but got Unknown
			//IL_0331: Unknown result type (might be due to invalid IL or missing references)
			//IL_033b: Expected O, but got Unknown
			//IL_0348: Unknown result type (might be due to invalid IL or missing references)
			//IL_0352: Expected O, but got Unknown
			int num = -1;
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			CodeInstruction item = new CodeInstruction(list[14].opcode, list[14].operand);
			for (int i = 0; i < list.Count - 29; i++)
			{
				if (((object)list[i]).ToString().StartsWith("ldloc.0") && ((object)list[i + 2]).ToString().StartsWith("callvirt bool Unity.Netcode.NetworkBehaviour::get_IsOwner()") && ((object)list[i + 29]).ToString().StartsWith("ldsfld MoreEmotes.Scripts.SignUI MoreEmotes.Patch.EmotePatch::s_customSignInputField"))
				{
					num = i;
					break;
				}
			}
			if (num > -1)
			{
				Label label = generator.DefineLabel();
				list[num + 29].labels.Add(label);
				list.Insert(num + 1, new CodeInstruction(list[num].opcode, list[num].operand));
				list[num].opcode = OpCodes.Nop;
				list[num].operand = null;
				num++;
				List<CodeInstruction> collection = new List<CodeInstruction>
				{
					new CodeInstruction(OpCodes.Ldloc_0, (object)null),
					item,
					new CodeInstruction(OpCodes.Call, (object)PatchesUtil.IsPlayerLethalBotControlledAndOwnerMethod),
					new CodeInstruction(OpCodes.Brtrue, (object)label)
				};
				list.InsertRange(num, collection);
				num = -1;
			}
			else
			{
				Plugin.LogError("LethalBot.Patches.ModPatches.MoreEmotesPatch.PerformEmotePrefix_Transpiler could not use irl number of player for iteration.");
			}
			for (int j = 0; j < list.Count - 1; j++)
			{
				if (((object)list[j]).ToString().StartsWith("ldarga.s 0") && ((object)list[j + 1]).ToString().StartsWith("call bool UnityEngine.InputSystem.InputAction+CallbackContext::get_performed()"))
				{
					num = j;
					break;
				}
			}
			if (num > -1)
			{
				Label label2 = generator.DefineLabel();
				list[num + 10].labels.Add(label2);
				List<CodeInstruction> collection2 = new List<CodeInstruction>
				{
					new CodeInstruction(OpCodes.Ldloc_0, (object)null),
					item,
					new CodeInstruction(OpCodes.Call, (object)PatchesUtil.IsPlayerLethalBotMethod),
					new CodeInstruction(OpCodes.Brtrue, (object)label2)
				};
				list.InsertRange(num, collection2);
				num = -1;
			}
			else
			{
				Plugin.LogError("LethalBot.Patches.ModPatches.MoreEmotesPatch.PerformEmotePrefix_Transpiler could not bypass context performed for bots.");
			}
			for (int k = 0; k < list.Count - 2; k++)
			{
				if (((object)list[k]).ToString().StartsWith("ldloc.0") && ((object)list[k + 1]).ToString().StartsWith("ldfld GameNetcodeStuff.PlayerControllerB MoreEmotes.Patch.EmotePatch+<>c__DisplayClass61_0::__instance") && ((object)list[k + 2]).ToString().StartsWith("ldfld float GameNetcodeStuff.PlayerControllerB::timeSinceStartingEmote"))
				{
					num = k;
					break;
				}
			}
			if (num > -1)
			{
				Label label3 = generator.DefineLabel();
				list[num + 11].labels.Add(label3);
				list.Insert(num + 1, new CodeInstruction(list[num].opcode, list[num].operand));
				list[num].opcode = OpCodes.Nop;
				list[num].operand = null;
				num++;
				List<CodeInstruction> collection3 = new List<CodeInstruction>
				{
					new CodeInstruction(OpCodes.Ldloc_0, (object)null),
					item,
					new CodeInstruction(OpCodes.Call, (object)PatchesUtil.IsPlayerLethalBotMethod),
					new CodeInstruction(OpCodes.Brtrue, (object)label3)
				};
				list.InsertRange(num, collection3);
				num = -1;
			}
			else
			{
				Plugin.LogError("LethalBot.Patches.ModPatches.MoreEmotesPatch.PerformEmotePrefix_Transpiler could not bypass timeSinceStartingEmote for bots.");
			}
			return list.AsEnumerable();
		}
	}
}
namespace LethalBots.Patches.ModPatches.ModelRplcmntAPI
{
	[HarmonyPatch(typeof(ModelReplacementAPI))]
	public class ModelReplacementAPIPatch
	{
		[HarmonyPatch("SetPlayerModelReplacement")]
		[HarmonyPrefix]
		private static bool SetPlayerModelReplacement_Prefix(PlayerControllerB player, Type type)
		{
			if (LethalBotManager.Instance.IsPlayerLethalBot(player))
			{
				if (!type.IsSubclassOf(typeof(BodyReplacementBase)))
				{
					Plugin.LogError("Cannot set body replacement of type " + type.Name + ", must inherit from BodyReplacementBase");
				}
				else
				{
					BodyReplacementBase val = default(BodyReplacementBase);
					bool flag = ((Component)player).gameObject.TryGetComponent<BodyReplacementBase>(ref val);
					int currentSuitID = player.currentSuitID;
					string unlockableName = StartOfRound.Instance.unlockablesList.unlockables[currentSuitID].unlockableName;
					if (flag)
					{
						if (((object)val).GetType() == type && val.suitName == unlockableName)
						{
							return false;
						}
						Plugin.LogInfo($"Model Replacement Change detected {((object)val).GetType()} => {type}, changing model.");
						val.IsActive = false;
						Object.Destroy((Object)(object)val);
					}
					Plugin.LogInfo($"Suit Change detected {((val != null) ? val.suitName : null)} => {unlockableName}, Replacing {type}.");
					Component obj = ((Component)player).gameObject.AddComponent(type);
					BodyReplacementBase val2 = (BodyReplacementBase)(object)((obj is BodyReplacementBase) ? obj : null);
					val2.suitName = unlockableName;
				}
				return false;
			}
			return true;
		}

		[HarmonyPatch("RemovePlayerModelReplacement")]
		[HarmonyTranspiler]
		public static IEnumerable<CodeInstruction> FixOpenBodyCamTranspilerRemovePlayerModelReplacement_Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator generator)
		{
			int num = -1;
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			for (int i = 0; i < list.Count - 1; i++)
			{
				if (((object)list[i]).ToString() == "call virtual void ModelReplacement.Monobehaviors.ManagerBase::ReportBodyReplacementRemoval()" && ((object)list[i + 1]).ToString() == "call NULL")
				{
					num = i;
					break;
				}
			}
			if (num > -1)
			{
				list[num + 1].opcode = OpCodes.Call;
				list[num + 1].operand = SymbolExtensions.GetMethodInfo(Expression.Lambda<Action>(Expression.Call(Expression.New(typeof(ViewStateManager)), (MethodInfo)MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), Array.Empty<Expression>()), Array.Empty<ParameterExpression>()));
				num = -1;
			}
			else
			{
				Plugin.LogInfo("LethalBot.Patches.ModPatches.ModelRplcmntAPI.ModelReplacementAPIPatch.FixOpenBodyCamTranspilerRemovePlayerModelReplacement_Transpiler, could not find call null line, ignoring fix.");
			}
			return list.AsEnumerable();
		}
	}
	[HarmonyPatch(typeof(PlayerControllerBPatch))]
	public class ModelReplacementPlayerControllerBPatchPatch
	{
		[HarmonyPatch("StartPatch")]
		[HarmonyPrefix]
		private static bool StartPatch_Prefix(PlayerControllerB __0)
		{
			if ((Object)(object)((Component)__0).gameObject.GetComponent<MoreCompanyCosmeticManager>() != (Object)null)
			{
				return false;
			}
			return true;
		}
	}
}
namespace LethalBots.Patches.ModPatches.LethalProgression
{
	public class HPRegenPatch
	{
		public static bool HPRegenUpdate_Prefix(PlayerControllerB __0)
		{
			if (LethalBotManager.Instance.IsPlayerLethalBot(__0))
			{
				return false;
			}
			return true;
		}
	}
	public class OxygenPatch
	{
		public static bool EnteredWater_Prefix(PlayerControllerB __0)
		{
			if (LethalBotManager.Instance.IsPlayerLethalBot(__0))
			{
				return false;
			}
			return true;
		}

		public static bool LeftWater_Prefix(PlayerControllerB __0)
		{
			if (LethalBotManager.Instance.IsPlayerLethalBot(__0))
			{
				return false;
			}
			return true;
		}

		public static bool ShouldDrown_Prefix(PlayerControllerB __0)
		{
			if (LethalBotManager.Instance.IsPlayerLethalBot(__0))
			{
				return false;
			}
			return true;
		}

		public static bool OxygenUpdate_Prefix(PlayerControllerB __0)
		{
			if (LethalBotManager.Instance.IsPlayerLethalBot(__0))
			{
				return false;
			}
			return true;
		}
	}
}
namespace LethalBots.Patches.ModPatches.LethalPhones
{
	[HarmonyPatch(typeof(AudioSourceStorage))]
	public class AudioSourceStoragePatch
	{
		[HarmonyPatch("ApplyPhoneEffect")]
		[HarmonyPrefix]
		private static bool ApplyPhoneEffect_Prefix(AudioSourceStorage __instance)
		{
			PlayerControllerB player = __instance.player;
			if (!LethalBotManager.Instance.IsPlayerLethalBot(player))
			{
				return true;
			}
			if (__instance.staticAudio)
			{
				if (Object.op_Implicit((Object)(object)((Component)__instance.audioSource).GetComponent<AudioLowPassFilter>()))
				{
					((Component)__instance.audioSource).GetComponent<AudioLowPassFilter>().cutoffFrequency = 3000f;
					((Component)__instance.audioSource).GetComponent<AudioLowPassFilter>().lowpassResonanceQ = 3f;
				}
				return false;
			}
			if (__instance.voice)
			{
				__instance.audioSource.spatialBlend = 0f;
			}
			if (Object.op_Implicit((Object)(object)((Component)__instance.audioSource).GetComponent<AudioLowPassFilter>()))
			{
				((Component)__instance.audioSource).GetComponent<AudioLowPassFilter>().cutoffFrequency = 3000f;
				((Component)__instance.audioSource).GetComponent<AudioLowPassFilter>().lowpassResonanceQ = Mathf.Lerp(3f, 10f, __instance.recordInterference);
			}
			if (Object.op_Implicit((Object)(object)((Component)__instance.audioSource).GetComponent<AudioHighPassFilter>()))
			{
				((Component)__instance.audioSource).GetComponent<AudioHighPassFilter>().cutoffFrequency = Mathf.Lerp(2000f, 2500f, __instance.recordInterference);
				((Component)__instance.audioSource).GetComponent<AudioHighPassFilter>().highpassResonanceQ = Mathf.Lerp(2f, 3f, __instance.recordInterference);
			}
			if (__instance.voice && player.voiceMuffledByEnemy && Object.op_Implicit((Object)(object)((Component)__instance.audioSource).GetComponent<AudioLowPassFilter>()))
			{
				((Component)__instance.audioSource).GetComponent<AudioLowPassFilter>().cutoffFrequency = 500f;
			}
			return false;
		}

		[HarmonyPatch("Reset")]
		[HarmonyPrefix]
		private static bool Reset_Prefix(AudioSourceStorage __instance, ref float ___origPan, ref float ___origSpatial, ref float ___origVolume, ref AnimationCurve ___origSpatialCurve, ref bool ___hadOcclude, ref bool ___hadLowPass, ref float ___origLowPass, ref float ___origLowPassResQ, ref bool ___hadHighPass, ref float ___origHighPass, ref float ___origHighPassResQ)
		{
			PlayerControllerB player = __instance.player;
			if (!LethalBotManager.Instance.IsPlayerLethalBot(player))
			{
				return true;
			}
			GameObject gameObject = ((Component)__instance.audioSource).gameObject;
			if (__instance.voice)
			{
				__instance.audioSource.spatialBlend = 1f;
			}
			if (__instance.staticAudio && __instance.audioSource.isPlaying)
			{
				__instance.audioSource.Stop();
			}
			__instance.audioSource.panStereo = ___origPan;
			__instance.audioSource.spatialBlend = ___origSpatial;
			__instance.audioSource.volume = ___origVolume;
			__instance.audioSource.SetCustomCurve((AudioSourceCurveType)1, ___origSpatialCurve);
			if (___hadOcclude && Object.op_Implicit((Object)(object)gameObject.GetComponent<OccludeAudio>()))
			{
				((Behaviour)gameObject.GetComponent<OccludeAudio>()).enabled = true;
				if (__instance.voice)
				{
					gameObject.GetComponent<OccludeAudio>().overridingLowPass = player.voiceMuffledByEnemy;
				}
			}
			if (Object.op_Implicit((Object)(object)gameObject.GetComponent<AudioLowPassFilter>()))
			{
				if (___hadLowPass)
				{
					gameObject.GetComponent<AudioLowPassFilter>().cutoffFrequency = ___origLowPass;
					gameObject.GetComponent<AudioLowPassFilter>().lowpassResonanceQ = ___origLowPassResQ;
				}
				else
				{
					((Behaviour)gameObject.GetComponent<AudioLowPassFilter>()).enabled = false;
				}
			}
			if (Object.op_Implicit((Object)(object)gameObject.GetComponent<AudioHighPassFilter>()))
			{
				if (___hadHighPass)
				{
					gameObject.GetComponent<AudioHighPassFilter>().cutoffFrequency = ___origHighPass;
					gameObject.GetComponent<AudioHighPassFilter>().highpassResonanceQ = ___origHighPassResQ;
				}
				else
				{
					((Behaviour)gameObject.GetComponent<AudioHighPassFilter>()).enabled = false;
				}
			}
			__instance.modified = false;
			return false;
		}
	}
	[HarmonyPatch(typeof(PhoneBehavior))]
	public class PhoneBehaviorPatch
	{
		public static FieldInfo incomingCall;

		public static FieldInfo outgoingCall;

		public static FieldInfo activeCall;

		public static FieldInfo incomingCaller;

		public static FieldInfo outgoingCaller;

		public static FieldInfo activeCaller;

		public static FieldInfo serverLeftArmRig;

		internal static void SetupReflectionFields()
		{
			incomingCall = AccessTools.Field(typeof(PhoneBehavior), "incomingCall");
			outgoingCall = AccessTools.Field(typeof(PhoneBehavior), "outgoingCall");
			activeCall = AccessTools.Field(typeof(PhoneBehavior), "activeCall");
			incomingCaller = AccessTools.Field(typeof(PhoneBehavior), "incomingCaller");
			outgoingCaller = AccessTools.Field(typeof(PhoneBehavior), "outgoingCaller");
			activeCaller = AccessTools.Field(typeof(PhoneBehavior), "activeCaller");
			serverLeftArmRig = AccessTools.Field(typeof(PlayerPhone), "serverLeftArmRig");
		}

		internal static ChainIKConstraint GetServerLeftArmRig(object obj)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Expected O, but got Unknown
			return (ChainIKConstraint)serverLeftArmRig.GetValue(obj);
		}

		internal static void TryWithPhone(Component phoneComp, Action<Component> action)
		{
			PlayerPhone val = (PlayerPhone)(object)((phoneComp is PlayerPhone) ? phoneComp : null);
			if ((Object)(object)val != (Object)null)
			{
				action((Component)(object)val);
			}
		}
	}
	[HarmonyPatch(typeof(PlayerPhone))]
	public class PlayerPhonePatch
	{
		[HarmonyPatch("ManageInputs")]
		[HarmonyPrefix]
		private static bool ManageInputs_Prefix(PlayerPhone __instance)
		{
			LethalBotAI lethalBotAI = LethalBotManager.Instance.GetLethalBotAI(__instance.player);
			if ((Object)(object)lethalBotAI != (Object)null)
			{
				return false;
			}
			return true;
		}

		[HarmonyPatch("SetNewPhoneNumberClientRpc")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> SetNewPhoneNumberClientRpc_Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator generator)
		{
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Expected O, but got Unknown
			int num = -1;
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			MethodInfo methodInfo = AccessTools.PropertyGetter(typeof(NetworkBehaviour), "IsOwner");
			for (int i = 0; i < list.Count; i++)
			{
				if (CodeInstructionExtensions.Calls(list[i], methodInfo))
				{
					num = i;
					break;
				}
			}
			if (num > -1)
			{
				list[num] = CodeInstructionExtensions.WithLabels(new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(PlayerPhonePatch), "IsPhoneLocal", (Type[])null, (Type[])null)), (IEnumerable<Label>)list[num].labels);
				num = -1;
			}
			else
			{
				Plugin.LogError("LethalBot.Patches.ModPatches.PlayerPhonePatch.SetNewPhoneNumberClientRpc_Transpiler could not find IsOwner check to bypass!");
			}
			return list.AsEnumerable();
		}

		[HarmonyPatch("LateUpdate")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> LateUpdate_Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator generator)
		{
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Expected O, but got Unknown
			int num = -1;
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			MethodInfo methodInfo = AccessTools.PropertyGetter(typeof(NetworkBehaviour), "IsOwner");
			for (int i = 0; i < list.Count; i++)
			{
				if (CodeInstructionExtensions.Calls(list[i], methodInfo))
				{
					num = i;
					break;
				}
			}
			if (num > -1)
			{
				list[num] = CodeInstructionExtensions.WithLabels(new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(PlayerPhonePatch), "IsPhoneLocal", (Type[])null, (Type[])null)), (IEnumerable<Label>)list[num].labels);
				num = -1;
			}
			else
			{
				Plugin.LogError("LethalBot.Patches.ModPatches.PlayerPhonePatch.LateUpdate_Transpiler could not find IsOwner check to bypass!");
			}
			return list.AsEnumerable();
		}

		[HarmonyPatch("ToggleServerPhoneModelClientRpc")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> ToggleServerPhoneModelClientRpc_Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator generator)
		{
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Expected O, but got Unknown
			int num = -1;
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			MethodInfo methodInfo = AccessTools.PropertyGetter(typeof(NetworkBehaviour), "IsOwner");
			for (int i = 0; i < list.Count; i++)
			{
				if (CodeInstructionExtensions.Calls(list[i], methodInfo))
				{
					num = i;
					break;
				}
			}
			if (num > -1)
			{
				list[num] = CodeInstructionExtensions.WithLabels(new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(PlayerPhonePatch), "IsPhoneLocal", (Type[])null, (Type[])null)), (IEnumerable<Label>)list[num].labels);
				num = -1;
			}
			else
			{
				Plugin.LogError("LethalBot.Patches.ModPatches.PlayerPhonePatch.ToggleServerPhoneModelClientRpc_Transpiler could not find IsOwner check to bypass!");
			}
			return list.AsEnumerable();
		}

		private static bool IsPhoneLocal(PlayerPhone playerPhone)
		{
			if ((Object)(object)playerPhone.player == (Object)null)
			{
				return ((NetworkBehaviour)playerPhone).IsOwner;
			}
			return LethalBotManager.IsPlayerLocal(playerPhone.player);
		}
	}
	[HarmonyPatch(typeof(PlayerPhonePatch))]
	public class PlayerPhonePatchPatch
	{
		[HarmonyPatch("PlayerDamaged")]
		[HarmonyPrefix]
		private static bool PlayerDamaged_Prefix(PlayerControllerB __0, int __1)
		{
			LethalBotAI lethalBotAIIfLocalIsOwner = LethalBotManager.Instance.GetLethalBotAIIfLocalIsOwner(__0);
			if ((Object)(object)lethalBotAIIfLocalIsOwner != (Object)null && __0.isPlayerControlled)
			{
				float num = Mathf.Clamp01((float)__1 / 75f);
				Transform obj = ((Component)__0).transform.Find("PhonePrefab(Clone)");
				PlayerPhone val = ((obj != null) ? ((Component)obj).GetComponent<PlayerPhone>() : null);
				if (val != null)
				{
					((PhoneBehavior)val).ApplyTemporaryInterference(num);
				}
				return false;
			}
			return true;
		}
	}
}
namespace LethalBots.Patches.ModPatches.LCVR
{
	public class LCVRPatchesPatch
	{
		public static bool BeforePlayerDeath_Prefix(PlayerControllerB __0)
		{
			if (LethalBotManager.Instance.IsPlayerLethalBot(__0))
			{
				return false;
			}
			return true;
		}

		public static bool OnPlayerDeath_Prefix(PlayerControllerB __0)
		{
			if (LethalBotManager.Instance.IsPlayerLethalBot(__0))
			{
				return false;
			}
			return true;
		}

		public static bool DisplaySafetyPatch_Prefix(PlayerControllerB __0)
		{
			if (LethalBotManager.Instance.IsPlayerLethalBot(__0))
			{
				return false;
			}
			return true;
		}

		public static bool AfterDamagePlayer_Prefix(PlayerControllerB __0)
		{
			if (LethalBotManager.Instance.IsPlayerLethalBot(__0))
			{
				return false;
			}
			return true;
		}
	}
}
namespace LethalBots.Patches.ModPatches.LCAlwaysHearActiveWalkie
{
	public class LCAlwaysHearActiveWalkiePatch
	{
	}
}
namespace LethalBots.Patches.ModPatches.DawnLib
{
	[HarmonyPatch(typeof(DawnMoonNetworker))]
	public class DawnMoonNetworkerPatch
	{
		[CompilerGenerated]
		private sealed class <MarkBotsAsReadyCoroutine>d__3 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public NetworkBehaviour dawnMoonNetworker;

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

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

			[DebuggerHidden]
			public <MarkBotsAsReadyCoroutine>d__3(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = null;
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					MarkBotsAsReadyDawnLib(dawnMoonNetworker);
					markBotsReadyCoroutine = null;
					return false;
				}
			}

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

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

		private static Coroutine? markBotsReadyCoroutine;

		[HarmonyPatch("QueueMoonSceneLoadingClientRpc")]
		[HarmonyPostfix]
		private static void QueueMoonSceneLoadingClientRpc_Postfix(DawnMoonNetworker __instance)
		{
			if (((NetworkBehaviour)__instance).IsServer || ((NetworkBehaviour)__instance).IsHost)
			{
				if (markBotsReadyCoroutine != null)
				{
					((MonoBehaviour)__instance).StopCoroutine(markBotsReadyCoroutine);
				}
				markBotsReadyCoroutine = ((MonoBehaviour)__instance).StartCoroutine(MarkBotsAsReadyCoroutine((NetworkBehaviour)(object)__instance));
			}
		}

		public static void MarkBotsAsReadyDawnLib(NetworkBehaviour dawnMoonNetworker)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Invalid comparison between Unknown and I4
			DawnMoonNetworker val = (DawnMoonNetworker)dawnMoonNetworker;
			FieldInfo fieldInfo = AccessTools.Field(typeof(DawnMoonNetworker), "_playerStates");
			Dictionary<PlayerControllerB, BundleState> dictionary = (Dictionary<PlayerControllerB, BundleState>)fieldInfo.GetValue(val);
			LethalBotAI[] lethalBotAIs = LethalBotManager.Instance.GetLethalBotAIs();
			LethalBotAI[] array = lethalBotAIs;
			foreach (LethalBotAI lethalBotAI in array)
			{
				PlayerControllerB val2 = lethalBotAI.NpcController?.Npc;
				if ((Object)(object)val2 != (Object)null && (val2.isPlayerControlled || val2.isPlayerDead) && dictionary.ContainsKey(val2) && (int)dictionary[val2] != 4)
				{
					val.PlayerSetBundleStateRpc(PlayerControllerReference.op_Implicit(val2), (BundleState)4);
				}
			}
		}

		[IteratorStateMachine(typeof(<MarkBotsAsReadyCoroutine>d__3))]
		private static IEnumerator MarkBotsAsReadyCoroutine(NetworkBehaviour dawnMoonNetworker)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <MarkBotsAsReadyCoroutine>d__3(0)
			{
				dawnMoonNetworker = dawnMoonNetworker
			};
		}
	}
}
namespace LethalBots.Patches.ModPatches.ButteryFixes
{
	public class BodyPatchesPatch
	{
		public static bool DeadBodyInfoPostStart_Prefix(DeadBodyInfo __0)
		{
			if ((Object)(object)__0.playerScript != (Object)null && LethalBotManager.Instance.IsPlayerLethalBot(__0.playerScript))
			{
				return false;
			}
			return true;
		}
	}
}
namespace LethalBots.Patches.ModPatches.BunkbedRevive
{
	[HarmonyPatch(typeof(BunkbedController))]
	public class BunkbedControllerPatch
	{
		[HarmonyPatch("OnInteract")]
		[HarmonyPrefix]
		private static bool OnInteract_PreFix(InteractTrigger ___interactTrigger)
		{
			//IL_0130: Unknown result type (might be due to invalid IL or missing references)
			RagdollGrabbableObject heldBody_ReversePatch = GetHeldBody_ReversePatch(BunkbedController.Instance);
			if ((Object)(object)heldBody_ReversePatch == (Object)null)
			{
				return true;
			}
			int num = (int)heldBody_ReversePatch.ragdoll.playerScript.playerClientId;
			string headerText = ((Component)heldBody_ReversePatch.ragdoll).gameObject.GetComponentInChildren<ScanNodeProperties>().headerText;
			LethalBotIdentity lethalBotIdentity = IdentityManager.Instance.FindIdentityFromBodyName(headerText);
			if (lethalBotIdentity == null)
			{
				return true;
			}
			if (lethalBotIdentity.Alive)
			{
				Plugin.LogError("BunkbedRevive with LethalBot: error when trying to revive bot \"" + lethalBotIdentity.Name + "\", bot is already alive! do nothing more");
				return false;
			}
			int reviveCost = BunkbedController.GetReviveCost();
			if (TerminalManager.Instance.GetTerminal().groupCredits < reviveCost)
			{
				HUDManagerPatch.DisplayGlobalNotification_ReversePatch(HUDManager.Instance, "Not enough credits");
				___interactTrigger.StopInteraction();
				return false;
			}
			if (!BunkbedController.CanRevive(heldBody_ReversePatch.bodyID, true))
			{
				HUDManagerPatch.DisplayGlobalNotification_ReversePatch(HUDManager.Instance, "Can't Revive");
				___interactTrigger.StopInteraction();
				return false;
			}
			Terminal terminal = TerminalManager.Instance.GetTerminal();
			terminal.groupCredits -= reviveCost;
			LethalBotManager.Instance.SyncGroupCreditsForNotOwnerTerminalServerRpc(terminal.groupCredits, terminal.numberOfItemsInDropship);
			LethalBotManager.Instance.SpawnThisLethalBotServerRpc(lethalBotIdentity.IdIdentity, new SpawnLethalBotParamsNetworkSerializable
			{
				ShouldDestroyDeadBody = true,
				ResetBodyBlood = true,
				enumSpawnAnimation = EnumSpawnAnimation.OnlyPlayerSpawnAnimation,
				SpawnPosition = StartOfRoundPatch.GetPlayerSpawnPosition_ReversePatch(StartOfRound.Instance, num, simpleTeleport: false),
				YRot = 0f,
				IsOutside = true,
				IndexNextPlayerObject = num
			});
			LethalBotManager.Instance.UpdateReviveCountServerRpc(num);
			StartOfRound instance = StartOfRound.Instance;
			instance.livingPlayers++;
			PlayerControllerB localPlayerController = GameNetworkManager.Instance.localPlayerController;
			if (localPlayerController != null)
			{
				localPlayerController.DespawnHeldObject();
			}
			HUDManagerPatch.DisplayGlobalNotification_ReversePatch(HUDManager.Instance, lethalBotIdentity.Name + " has been revived");
			return false;
		}

		[HarmonyPatch("Update")]
		[HarmonyPostfix]
		private static void Update_PostFix(InteractTrigger ___interactTrigger)
		{
			if (!((Object)(object)StartOfRound.Instance == (Object)null) && !((Object)(object)GameNetworkManager.Instance == (Object)null) && !((Object)(object)GameNetworkManager.Instance.localPlayerController == (Object)null))
			{
				RagdollGrabbableObject heldBody_ReversePatch = GetHeldBody_ReversePatch(BunkbedController.Instance);
				if (!((Object)(object)heldBody_ReversePatch == (Object)null) && (Object)(object)heldBody_ReversePatch.ragdoll != (Object)null && LethalBotManager.Instance.IsPlayerLethalBot(heldBody_ReversePatch.ragdoll.playerScript))
				{
					___interactTrigger.interactable = true;
				}
			}
		}

		[HarmonyPatch("GetHeldBody")]
		[HarmonyReversePatch(/*Could not decode attribute arguments.*/)]
		[HarmonyPriority(0)]
		public static RagdollGrabbableObject? GetHeldBody_ReversePatch(object instance)
		{
			throw new NotImplementedException("Stub LethalBot.Patches.ModPatches.BunkbedRevive.BunkbedControllerPatch.GetHeldBody_ReversePatch");
		}
	}
}
namespace LethalBots.Patches.ModPatches.BetterEmotes
{
	[HarmonyPatch(typeof(CustomAnimationObjects))]
	public class BetterEmotesCustomAnimationObjectsPatch
	{
		[HarmonyPatch("Update")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> Update_Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator generator)
		{
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Expected O, but got Unknown
			bool flag = false;
			int num = 0;
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			MethodInfo methodInfo = AccessTools.PropertyGetter(typeof(NetworkBehaviour), "IsOwner");
			FieldInfo fieldInfo = AccessTools.Field(typeof(CustomAnimationObjects), "playerInstance");
			Plugin.LogDebug("Beginning to patch CustomAnimationObjects.Update!");
			for (int i = 0; i < list.Count - 2; i++)
			{
				if (CodeInstructionExtensions.IsLdarg(list[i], (int?)0) && CodeInstructionExtensions.LoadsField(list[i + 1], fieldInfo, false) && CodeInstructionExtensions.Calls(list[i + 2], methodInfo))
				{
					Plugin.LogDebug($"Patching playerInstance.IsOwner check at index {i}...");
					Plugin.LogDebug($"Original Codes: 1: {list[i]}, 2: {list[i + 1]}, and 3: {list[i + 2]}");
					list[i + 2] = new CodeInstruction(OpCodes.Call, (object)PatchesUtil.IsPlayerLocalMethod);
					flag = true;
					num++;
				}
			}
			if (!flag)
			{
				Plugin.LogError("LethalBots.Patches.ModPatches.BetterEmotes.Update_Transpiler could not change code to only run for local player.");
			}
			else
			{
				Plugin.LogDebug($"Patched out playerInstance.IsOwner {num} times!");
			}
			return list.AsEnumerable();
		}

		[HarmonyPatch("DisableEverything")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> DisableEverything_Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator generator)
		{
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Expected O, but got Unknown
			bool flag = false;
			int num = 0;
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			MethodInfo methodInfo = AccessTools.PropertyGetter(typeof(NetworkBehaviour), "IsOwner");
			FieldInfo fieldInfo = AccessTools.Field(typeof(CustomAnimationObjects), "playerInstance");
			Plugin.LogDebug("Beginning to patch CustomAnimationObjects.DisableEverything!");
			for (int i = 0; i < list.Count - 2; i++)
			{
				if (CodeInstructionExtensions.IsLdarg(list[i], (int?)0) && CodeInstructionExtensions.LoadsField(list[i + 1], fieldInfo, false) && CodeInstructionExtensions.Calls(list[i + 2], methodInfo))
				{
					Plugin.LogDebug($"Patching playerInstance.IsOwner check at index {i}...");
					Plugin.LogDebug($"Original Codes: 1: {list[i]}, 2: {list[i + 1]}, and 3: {list[i + 2]}");
					list[i + 2] = new CodeInstruction(OpCodes.Call, (object)PatchesUtil.IsPlayerLocalMethod);
					flag = true;
					num++;
				}
			}
			if (!flag)
			{
				Plugin.LogError("LethalBots.Patches.ModPatches.BetterEmotes.DisableEverything_Transpiler could not change code to only run for local player.");
			}
			else
			{
				Plugin.LogDebug($"Patched out playerInstance.IsOwner {num} times!");
			}
			return list.AsEnumerable();
		}
	}
	public class BetterEmotesPatch
	{
		public static bool StartPostfix_Prefix(PlayerControllerB __0)
		{
			if ((Object)(object)((Component)__0).gameObject.GetComponent<CustomAnimationObjects>() != (Object)null)
			{
				return false;
			}
			return true;
		}

		public static IEnumerable<CodeInstruction> UpdatePostfix_Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator generator)
		{
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Expected O, but got Unknown
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Expected O, but got Unknown
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Expected O, but got Unknown
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Expected O, but got Unknown
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Expected O, but got Unknown
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Expected O, but got Unknown
			int num = 7;
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			Label label = generator.DefineLabel();
			list[num + 25].labels.Add(label);
			Label label2 = generator.DefineLabel();
			list[num + 20].labels.Add(label2);
			List<CodeInstruction> collection = new List<CodeInstruction>
			{
				new CodeInstruction(OpCodes.Ldarg_0, (object)null),
				new CodeInstruction(OpCodes.Call, (object)PatchesUtil.IsPlayerLethalBotOwnerLocalMethod),
				new CodeInstruction(OpCodes.Brtrue, (object)label),
				new CodeInstruction(OpCodes.Ldarg_0, (object)null),
				new CodeInstruction(OpCodes.Call, (object)PatchesUtil.IsPlayerLethalBotMethod),
				new CodeInstruction(OpCodes.Brtrue, (object)label2)
			};
			list.InsertRange(num, collection);
			return list.AsEnumerable();
		}

		public static IEnumerable<CodeInstruction> PerformEmotePrefix_Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator generator)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Expected O, but got Unknown
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Expected O, but got Unknown
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: Expected O, but got Unknown
			//IL_0121: Unknown result type (might be due to invalid IL or missing references)
			//IL_012b: Expected O, but got Unknown
			//IL_0138: Unknown result type (might be due to invalid IL or missing references)
			//IL_0142: Expected O, but got Unknown
			//IL_01d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e2: Expected O, but got Unknown
			//IL_01f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fe: Expected O, but got Unknown
			//IL_020b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0215: Expected O, but got Unknown
			//IL_02d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e3: Expected O, but got Unknown
			//IL_0311: Unknown result type (might be due to invalid IL or missing references)
			//IL_031b: Expected O, but got Unknown
			//IL_032d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0337: Expected O, but got Unknown
			//IL_0344: Unknown result type (might be due to invalid IL or missing references)
			//IL_034e: Expected O, but got Unknown
			int num = -1;
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			CodeInstruction item = new CodeInstruction(list[6].opcode, list[6].operand);
			for (int i = 0; i < list.Count - 24; i++)
			{
				if (((object)list[i]).ToString().StartsWith("ldloc.0") && ((object)list[i + 2]).ToString().StartsWith("callvirt bool Unity.Netcode.NetworkBehaviour::get_IsOwner()") && ((object)list[i + 24]).ToString().StartsWith("ldsfld BetterEmote.Netcode.SyncVRState BetterEmote.Patches.EmotePatch::syncVR"))
				{
					num = i;
					break;
				}
			}
			if (num > -1)
			{
				Label label = generator.DefineLabel();
				list[num + 24].labels.Add(label);
				list.Insert(num + 1, new CodeInstruction(list[num].opcode, list[num].operand));
				list[num].opcode = OpCodes.Nop;
				list[num].operand = null;
				num++;
				List<CodeInstruction> collection = new List<CodeInstruction>
				{
					new CodeInstruction(OpCodes.Ldloc_0, (object)null),
					item,
					new CodeInstruction(OpCodes.Call, (object)PatchesUtil.IsPlayerLethalBotControlledAndOwnerMethod),
					new CodeInstruction(OpCodes.Brtrue, (object)label)
				};
				list.InsertRange(num, collection);
				num = -1;
			}
			else
			{
				Plugin.LogError("LethalBot.Patches.ModPatches.BetterEmotesPatch.PerformEmotePrefix_Transpiler could not use irl number of player for iteration.");
			}
			for (int j = 0; j < list.Count - 1; j++)
			{
				if (((object)list[j]).ToString().StartsWith("ldarg.0") && ((object)list[j + 1]).ToString().StartsWith("call bool UnityEngine.InputSystem.InputAction+CallbackContext::get_performed()"))
				{
					num = j;
					break;
				}
			}
			if (num > -1)
			{
				Label label2 = generator.DefineLabel();
				list[num + 7].labels.Add(label2);
				List<CodeInstruction> collection2 = new List<CodeInstruction>
				{
					new CodeInstruction(OpCodes.Ldloc_0, (object)null),
					item,
					new CodeInstruction(OpCodes.Call, (object)PatchesUtil.IsPlayerLethalBotMethod),
					new CodeInstruction(OpCodes.Brtrue, (object)label2)
				};
				list.InsertRange(num, collection2);
				num = -1;
			}
			else
			{
				Plugin.LogError("LethalBot.Patches.ModPatches.BetterEmotesPatch.PerformEmotePrefix_Transpiler could not bypass context performed for bots.");
			}
			for (int k = 0; k < list.Count - 2; k++)
			{
				if (((object)list[k]).ToString().StartsWith("ldloc.0") && ((object)list[k + 1]).ToString().StartsWith("ldfld GameNetcodeStuff.PlayerControllerB") && ((object)list[k + 2]).ToString().StartsWith("ldfld float GameNetcodeStuff.PlayerControllerB::timeSinceStartingEmote"))
				{
					num = k;
					break;
				}
			}
			if (num > -1)
			{
				Label label3 = generator.DefineLabel();
				list[num + 5].labels.Add(label3);
				list.Insert(num + 1, new CodeInstruction(list[num].opcode, list[num].operand));
				list[num].opcode = OpCodes.Nop;
				list[num].operand = null;
				num++;
				List<CodeInstruction> collection3 = new List<CodeInstruction>
				{
					new CodeInstruction(OpCodes.Ldloc_0, (object)null),
					item,
					new CodeInstruction(OpCodes.Call, (object)PatchesUtil.IsPlayerLethalBotMethod),
					new CodeInstruction(OpCodes.Brtrue, (object)label3)
				};
				list.InsertRange(num, collection3);
				num = -1;
			}
			else
			{
				Plugin.LogError("LethalBot.Patches.ModPatches.BetterEmotesPatch.PerformEmotePrefix_Transpiler could not bypass timeSinceStartingEmote for bots.");
			}
			return list.AsEnumerable();
		}
	}
}
namespace LethalBots.Patches.ModPatches.AutoRevive
{
	[HarmonyPatch(typeof(RevivePlayer))]
	public class AutoRevivePlayerPatch
	{
		[HarmonyPatch("ReiveDeadPlayer")]
		[HarmonyPrefix]
		private static bool ReiveDeadPlayer_Prefix(int playerId)
		{
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			LethalBotAI lethalBotAI = LethalBotManager.Instance.GetLethalBotAI(playerId);
			if ((Object)(object)lethalBotAI == (Object)null)
			{
				return true;
			}
			PlayerControllerB val = StartOfRound.Instance.allPlayerScripts[playerId];
			if ((Object)(object)val == (Object)null)
			{
				Plugin.LogError("Auto Revive with LethalBot: error when trying to revive bot, could not find player controller.");
				return false;
			}
			LethalBotIdentity lethalBotIdentity = lethalBotAI.LethalBotIdentity;
			if (lethalBotIdentity == null)
			{
				return true;
			}
			if (lethalBotIdentity.Alive)
			{
				Plugin.LogError("Auto Revive with LethalBot: error when trying to revive bot \"" + lethalBotIdentity.Name + "\", bot is already alive! do nothing more");
				return false;
			}
			if (!NetworkManager.Singleton.IsServer)
			{
				return false;
			}
			int num = (int)val.playerClientId;
			Plugin.LogDebug("Reviving bot " + lethalBotIdentity.Name);
			LethalBotManager.Instance.SpawnThisLethalBotServerRpc(lethalBotIdentity.IdIdentity, new SpawnLethalBotParamsNetworkSerializable
			{
				ShouldDestroyDeadBody = true,
				ResetBodyBlood = true,
				enumSpawnAnimation = EnumSpawnAnimation.OnlyPlayerSpawnAnimation,
				SpawnPosition = StartOfRoundPatch.GetPlayerSpawnPosition_ReversePatch(StartOfRound.Instance, num, simpleTeleport: false),
				YRot = 0f,
				IsOutside = true,
				IndexNextPlayerObject = num
			});
			StartOfRound instance = StartOfRound.Instance;
			instance.livingPlayers++;
			return false;
		}
	}
	public class LethalBotAutoReviveHelper
	{
		public class AutoReviveHandler
		{
			[CompilerGenerated]
			private sealed class <WaitForPlayerRevival>d__11 : IEnumerator<object>, IEnumerator, IDisposable
			{
				private int <>1__state;

				private object <>2__current;

				public AutoReviveHandler <>4__this;

				private float <timeLeft>5__2;

				private float <interval>5__3;

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

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

				[DebuggerHidden]
				public <WaitForPlayerRevival>d__11(int <>1__state)
				{
					this.<>1__state = <>1__state;
				}

				[DebuggerHidden]
				void IDisposable.Dispose()
				{
					<>1__state = -2;
				}

				private bool MoveNext()
				{
					//IL_009f: Unknown result type (might be due to invalid IL or missing references)
					//IL_00a9: Expected O, but got Unknown
					int num = <>1__state;
					AutoReviveHandler autoReviveHandler = <>4__this;
					switch (num)
					{
					default:
						return false;
					case 0:
					{
						<>1__state = -1;
						FieldInfo fieldInfo = AccessTools.Field(typeof(LCAutoRevive), "reviveDelayPenalty");
						FieldInfo fieldInfo2 = AccessTools.Field(typeof(LCAutoRevive), "reviveDelay");
						float num2 = (float)fieldInfo.GetValue(null);
						float num3 = (float)fieldInfo2.GetValue(null);
						autoReviveHandler.isRunning = true;
						<timeLeft>5__2 = ((num2 >= 0f) ? (num3 + num2 * (float)autoReviveHandler.reviveCount) : num3);
						<interval>5__3 = 0.1f;
						break;
					}
					case 1:
						<>1__state = -1;
						if (<interval>5__3 > 0f)
						{
							<interval>5__3 -= Time.deltaTime;
							break;
						}
						if (StartOfRound.Instance.shipIsLeaving || StartOfRound.Instance.inShipPhase)
						{
							autoReviveHandler.isRunning = false;
							autoReviveHandler.reviveCount = 0;
							autoReviveHandler.reviveCoroutine = null;
							return false;
						}
						<interval>5__3 = 0.1f;
						<timeLeft>5__2 -= 0.1f + (<interval>5__3 - 0.1f) + Time.deltaTime;
						break;
					}
					if (<timeLeft>5__2 >= 0f)
					{
						<>2__current = (object)new WaitForEndOfFrame();
						<>1__state = 1;
						return true;
					}
					autoReviveHandler.canRevive = true;
					if (!StartOfRound.Instance.shipIsLeaving && !StartOfRound.Instance.inShipPhase)
					{
						try
						{
							Type type = AccessTools.TypeByName("LCAutoRevive.Network.NetworkHandler");
							if (type != null)
							{
								MethodInfo methodInfo = AccessTools.PropertyGetter(type, "Instance");
								if (methodInfo != null)
								{
									object obj = methodInfo.Invoke(null, null);
									MethodInfo methodInfo2 = AccessTools.Method(type, "RevivePlayerServerRpc", (Type[])null, (Type[])null);
									if (methodInfo2 != null)
									{
										methodInfo2.Invoke(obj, new object[1] { (int)autoReviveHandler.playerController.playerClientId });
										autoReviveHandler.canRevive = false;
										autoReviveHandler.reviveCount++;
										Plugin.LogDebug("Successfully invoked revivePlayerServerRpc via AccessTools.");
									}
									else
									{
										Plugin.LogWarning("Could not find revivePlayerServerRpc field.");
									}
								}
								else
								{
									Plugin.LogWarning("Could not find Instance property.");
								}
							}
							else
							{
								Plugin.LogWarning("Could not find NetworkHandler type from Auto Revive.");
							}
						}
						catch (Exception arg)
						{
							Plugin.LogError($"Error while trying to respawn bot using Auto Revive: {arg}");
						}
					}
					autoReviveHandler.reviveCoroutine = null;
					autoReviveHandler.isRunning = false;
					return false;
				}

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

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

			public bool canRevive;

			public bool isRunning;

			public bool isPermaDead;

			public int reviveCount;

			public PlayerControllerB playerController;

			public Coroutine? reviveCoroutine;

			public AutoReviveHandler(PlayerControllerB playerController)
			{
				this.playerController = playerController;
			}

			~AutoReviveHandler()
			{
				if ((Object)(object)playerController != (Object)null && reviveCoroutine != null)
				{
					((MonoBehaviour)playerController).StopCoroutine(reviveCoroutine);
				}
			}

			public void OnPlayerDC()
			{
				if (reviveCoroutine != null)
				{
					((MonoBehaviour)playerController).StopCoroutine(reviveCoroutine);
					reviveCoroutine = null;
				}
				if (!playerController.disconnectedMidGame || !NetworkManager.Singleton.IsServer)
				{
					return;
				}
				try
				{
					Type type = AccessTools.TypeByName("LCAutoRevive.Network.NetworkHandler");
					if (type != null)
					{
						MethodInfo methodInfo = AccessTools.PropertyGetter(type, "Instance");
						if (methodInfo != null)
						{
							object obj = methodInfo.Invoke(null, null);
							MethodInfo methodInfo2 = AccessTools.Method(type, "DisconnectPermaDeadPlayer", (Type[])null, (Type[])null);
							if (methodInfo2 != null)
							{
								methodInfo2.Invoke(obj, new object[1] { (int)playerController.actualClientId });
								Plugin.LogDebug("Successfully invoked disconnectPermaDeadPlayer via AccessTools.");
							}
							else
							{
								Plugin.LogWarning("Could not find disconnectPermaDeadPlayer field.");
							}
						}
						else
						{
							Plugin.LogWarning("Could not find Instance property.");
						}
					}
					else
					{
						Plugin.LogWarning("Could not find NetworkHandler type from Auto Revive.");
					}
				}
				catch (Exception arg)
				{
					Plugin.LogError($"Error while trying to DisconnectPermaDead bot using Auto Revive: {arg}");
				}
			}

			public void OnActionPreformed()
			{
				FieldInfo fieldInfo = AccessTools.Field(typeof(LCAutoRevive), "reviveLimit");
				int num = (int)fieldInfo.GetValue(null);
				if (StartOfRound.Instance.shipIsLeaving || StartOfRound.Instance.inShipPhase || !canRevive || (num > 0 && reviveCount >= num))
				{
					return;
				}
				try
				{
					Type type = AccessTools.TypeByName("LCAutoRevive.Network.NetworkHandler");
					if (type != null)
					{
						MethodInfo methodInfo = AccessTools.PropertyGetter(type, "Instance");
						if (methodInfo != null)
						{
							object obj = methodInfo.Invoke(null, null);
							MethodInfo methodInfo2 = AccessTools.Method(type, "RevivePlayerServerRpc", (Type[])null, (Type[])null);
							if (methodInfo2 != null)
							{
								methodInfo2.Invoke(obj, new object[1] { (int)playerController.playerClientId });
								canRevive = false;
								reviveCount++;
								Plugin.LogDebug("Successfully invoked revivePlayerServerRpc via AccessTools.");
							}
							else
							{
								Plugin.LogWarning("Could not find revivePlayerServerRpc field.");
							}
						}
						else
						{
							Plugin.LogWarning("Could not find Instance property.");
						}
					}
					else
					{
						Plugin.LogWarning("Could not find NetworkHandler type from Auto Revive.");
					}
				}
				catch (Exception arg)
				{
					Plugin.LogError($"Error while trying to respawn bot using Auto Revive: {arg}");
				}
			}

			public void StartPlayerReviveCountDown()
			{
				if (isRunning || isPermaDead)
				{
					return;
				}
				canRevive = false;
				FieldInfo fieldInfo = AccessTools.Field(typeof(LCAutoRevive), "reviveLimit");
				int num = (int)fieldInfo.GetValue(null);
				if (reviveCount >= num && num > 0)
				{
					try
					{
						Type type = AccessTools.TypeByName("LCAutoRevive.Network.NetworkHandler");
						if (type != null)
						{
							MethodInfo methodInfo = AccessTools.PropertyGetter(type, "Instance");
							if (methodInfo != null)
							{
								object obj = methodInfo.Invoke(null, null);
								MethodInfo methodInfo2 = AccessTools.Method(type, "PermaDeadPlayerServerRpc", (Type[])null, (Type[])null);
								if (methodInfo2 != null)
								{
									methodInfo2.Invoke(obj, new object[1] { (int)playerController.playerClientId });
									isPermaDead = true;
									Plugin.LogDebug("Successfully invoked permaDeadPlayerServerRpc via AccessTools.");
								}
								else
								{
									Plugin.LogWarning("Could not find permaDeadPlayerServerRpc field.");
								}
							}
							else
							{
								Plugin.LogWarning("Could not find Instance property.");
							}
						}
						else
						{
							Plugin.LogWarning("Could not find NetworkHandler type from Auto Revive.");
						}
						return;
					}
					catch (Exception arg)
					{
						Plugin.LogError($"Error while trying to mark bot as permadead using Auto Revive: {arg}");
						return;
					}
				}
				if (reviveCoroutine != null)
				{
					((MonoBehaviour)playerController).StopCoroutine(reviveCoroutine);
				}
				reviveCoroutine = ((MonoBehaviour)playerController).StartCoroutine(WaitForPlayerRevival());
			}

			[IteratorStateMachine(typeof(<WaitForPlayerRevival>d__11))]
			private IEnumerator WaitForPlayerRevival()
			{
				//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
				return new <WaitForPlayerRevival>d__11(0)
				{
					<>4__this = this
				};
			}

			public void ShipLeave()
			{
				canRevive = false;
				reviveCount = 0;
			}
		}

		internal static Dictionary<PlayerControllerB, AutoReviveHandler> autoReviveHandlers = new Dictionary<PlayerControllerB, AutoReviveHandler>();

		public static AutoReviveHandler GetAutoReviveHandler(PlayerControllerB player)
		{
			if (!autoReviveHandlers.TryGetValue(player, out AutoReviveHandler value))
			{
				value = new AutoReviveHandler(player);
				autoReviveHandlers[player] = value;
			}
			return value;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static void RemoveAutoReviveHandler(PlayerControllerB player)
		{
			autoReviveHandlers.Remove(player);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static void ClearAutoReviveHandlers()
		{
			autoReviveHandlers.Clear();
		}

		public static bool KillPlayerPostfix_Prefix(PlayerControllerB __0)
		{
			if (((NetworkBehaviour)__0).IsOwner && __0.isPlayerDead && __0.AllowPlayerDeath() && LethalBotManager.Instance.IsPlayerLethalBot(__0))
			{
				AutoReviveHandler autoReviveHandler = GetAutoReviveHandler(__0);
				autoReviveHandler.StartPlayerReviveCountDown();
				return false;
			}
			return true;
		}

		public static void ReviveDeadPlayersPostfix_Postfix()
		{
			foreach (AutoReviveHandler value in autoReviveHandlers.Values)
			{
				if (value.reviveCoroutine != null)
				{
					((MonoBehaviour)value.playerController).StopCoroutine(value.reviveCoroutine);
					value.reviveCoroutine = null;
				}
			}
			ClearAutoReviveHandlers();
		}

		public static void ShipLeavePostfix_Postfix(StartOfRound __0)
		{
			if (!__0.shipIsLeaving)
			{
				return;
			}
			foreach (AutoReviveHandler value in autoReviveHandlers.Values)
			{
				value.ShipLeave();
			}
		}

		public static IEnumerable<CodeInstruction> CheckIfAllPlayersDead_Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator generator)
		{
			int num = -1;
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			MethodInfo methodInfo = AccessTools.PropertyGetter(typeof(GameNetworkManager), "Instance");
			FieldInfo fieldInfo = AccessTools.Field(typeof(GameNetworkManager), "connectedPlayers");
			for (int i = 0; i < list.Count - 1; i++)
			{
				if (CodeInstructionExtensions.Calls(list[i], methodInfo) && CodeInstructionExtensions.LoadsField(list[i + 1], fieldInfo, false))
				{
					num = i;
					break;
				}
			}
			if (num > -1)
			{
				list[num].opcode = OpCodes.Nop;
				list[num].operand = null;
				list[num + 1].opcode = OpCodes.Call;
				list[num + 1].operand = AccessTools.Method(typeof(LethalBotAutoReviveHelper), "GetNumberOfConnectedPlayers", (Type[])null, (Type[])null);
			}
			else
			{
				Plugin.LogError("LethalBot.Patches.ModPatches.AutoRevive.LethalBotAutoReviveHelper.CheckIfAllPlayersDead_Transpiler could not locate the target instructions for replacement.");
			}
			return list.AsEnumerable();
		}

		private static int GetNumberOfConnectedPlayers()
		{
			return StartOfRound.Instance.connectedPlayersAmount + 1;
		}
	}
}
namespace LethalBots.Patches.ModPatches.AdditionalNetworking
{
	public class AdditionalNetworkingPatch
	{
		public static IEnumerable<CodeInstruction> Start_Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator generator)
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Expected O, but got Unknown
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Expected O, but got Unknown
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Expected O, but got Unknown
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Expected O, but got Unknown
			int index = 0;
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			Label label = generator.DefineLabel();
			list[index].labels.Add(label);
			List<CodeInstruction> collection = new List<CodeInstruction>
			{
				new CodeInstruction(OpCodes.Ldarg_0, (object)null),
				new CodeInstruction(OpCodes.Call, (object)PatchesUtil.IsPlayerLethalBotMethod),
				new CodeInstruction(OpCodes.Brfalse, (object)label),
				new CodeInstruction(OpCodes.Ret, (object)null)
			};
			list.InsertRange(index, collection);
			return list.AsEnumerable();
		}
	}
}
namespace LethalBots.Patches.MapPatches
{
	[HarmonyPatch(typeof(AnimatedObjectFloatSetter))]
	public class AnimatedObjectFloatSetterPatch
	{
		[HarmonyPatch("KillPlayerAtPoint")]
		[HarmonyPostfix]
		private static void KillPlayerAtPoint_Postfix(AnimatedObjectFloatSetter __instance)
		{
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)__instance.killPlayerPoint == (Object)null)
			{
				return;
			}
			LethalBotAI[] lethalBotsAIOwnedByLocal = LethalBotManager.Instance.GetLethalBotsAIOwnedByLocal();
			LethalBotAI[] array = lethalBotsAIOwnedByLocal;
			for (int i = 0; i < array.Length; i++)
			{
				PlayerControllerB val = array[i]?.NpcController?.Npc;
				if ((Object)(object)val != (Object)null && !val.isPlayerDead)
				{
					Vector3 position = __instance.killPlayerPoint.position;
					if (__instance.ignoreVerticalDistance)
					{
						position.y = ((Component)val).transform.position.y;
					}
					Vector3 val2 = ((Component)val).transform.position - position;
					if (((Vector3)(ref val2)).sqrMagnitude < __instance.killRange * __instance.killRange)
					{
						Vector3 zero = Vector3.zero;
						val2 = default(Vector3);
						val.KillPlayer(zero, true, (CauseOfDeath)8, 0, val2, false);
					}
				}
			}
		}
	}
	[HarmonyPatch(typeof(CompanyMonsterCollisionDetect))]
	public class CompanyMonsterCollisionDetectPatch
	{
		[HarmonyPatch("OnTriggerEnter")]
		[HarmonyPrefix]
		private static bool OnTriggerEnter_Prefix(CompanyMonsterCollisionDetect __instance, Collider other)
		{
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Expected I4, but got Unknown
			if (!((Component)other).CompareTag("Player"))
			{
				return true;
			}
			PlayerControllerB component = ((Component)other).gameObject.GetComponent<PlayerControllerB>();
			if ((Object)(object)component != (Object)null && !component.isPlayerDead && ((NetworkBehaviour)component).IsOwner && LethalBotManager.Instance.IsPlayerLethalBot(component))
			{
				DepositItemsDesk companyDesk = LethalBotManager.CompanyDesk;
				if ((Object)(object)companyDesk != (Object)null && companyDesk.attacking && !companyDesk.monsterAnimations[__instance.monsterAnimationID].animatorCollidedOnClient)
				{
					companyDesk.monsterAnimations[__instance.monsterAnimationID].animatorCollidedOnClient = true;
					if (((NetworkBehaviour)companyDesk).IsServer)
					{
						companyDesk.ConfirmAnimationGrabPlayerClientRpc(__instance.monsterAnimationID, (int)component.playerClientId);
					}
					else
					{
						companyDesk.CheckAnimationGrabPlayerServerRpc(__instance.monsterAnimationID, (int)component.playerClientId);
					}
					CompanyMonster manifestation = companyDesk.currentMood.manifestation;
					switch ((int)manifestation)
					{
					case 1:
						Plugin.LogInfo("Tentacle collision");
						break;
					case 2:
						Plugin.LogInfo("Tongue collision");
						break;
					case 0:
						Plugin.LogInfo("Hand collision");
						break;
					}
				}
				return false;
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(DepositItemsDesk))]
	public class DepositItemsDeskPatch
	{
		[HarmonyPatch("INoiseListener.DetectNoise")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> DetectNoise_Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator generator)
		{
			int num = -1;
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			MethodInfo methodInfo = AccessTools.PropertyGetter(typeof(StartOfRound), "Instance");
			FieldInfo fieldInfo = AccessTools.Field(typeof(StartOfRound), "connectedPlayersAmount");
			for (int i = 0; i < list.Count - 2; i++)
			{
				if (CodeInstructionExtensions.Calls(list[i], methodInfo) && CodeInstructionExtensions.LoadsField(list[i + 1], fieldInfo, false))
				{
					num = i;
					break;
				}
			}
			if (num > -1)
			{
				list[num].opcode = OpCodes.Call;
				list[num].operand = PatchesUtil.AllRealPlayersCountMethod;
				list[num + 1].opcode = OpCodes.Nop;
				list[num + 1].operand = null;
				num = -1;
			}
			else
			{
				Plugin.LogError("LethalBot.Patches.MapPatches.DepositItemDeskPatch.DetectNoise_Transpiler use other method for detecting player sounds!");
			}
			return list.AsEnumerable();
		}

		[HarmonyPatch("PlaceItemOnCounter")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> PlaceItemOnCounter_Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator generator)
		{
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: 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");
			MethodInfo methodInfo2 = AccessTools.Method(typeof(Object), "op_Equality", (Type[])null, (Type[])null);
			for (int i = 0; i < list.Count - 2; i++)
			{
				if (CodeInstructionExtensions.Calls(list[i], methodInfo) && CodeInstructionExtensions.LoadsField(list[i + 1], fieldInfo, false) && CodeInstructionExtensions.Calls(list[i + 2], methodInfo2))
				{
					num = i;
					break;
				}
			}
			if (num > -1)
			{
				list.RemoveRange(num, 3);
				list.Insert(num, new CodeInstruction(OpCodes.Call, (object)PatchesUtil.IsPlayerLocalOrLethalBotOwnerLocalMethod));
				num = -1;
			}
			else
			{
				Plugin.LogError("LethalBot.Patches.MapPatches.DepositItemDeskPatch.PlaceItemOnCounter_Transpiler failed to allow bots to use PlaceItemOnCounter!");
			}
			return list.AsEnumerable();
		}
	}
	[HarmonyPatch(typeof(DoorLock))]
	public class DoorLockPatch
	{
		[HarmonyPatch("OpenOrCloseDoor")]
		[HarmonyPrefix]
		private static bool OpenOrCloseDoor_PreFix(DoorLock __instance, bool ___isLocked, bool ___isDoorOpened, PlayerControllerB playerWhoTriggered)
		{
			if (LethalBotManager.Instance.GetLethalBotAIIfLocalIsOwner(playerWhoTriggered)?.NpcController.Npc.playerClientId != playerWhoTriggered.playerClientId)
			{
				return true;
			}
			if (___isLocked || ___isDoorOpened)
			{
				return false;
			}
			__instance.OpenDoorAsEnemy(true);
			return true;
		}
	}
	[HarmonyPatch(typeof(InteractTrigger))]
	public class InteractTriggerPatch
	{
		[CompilerGenerated]
		private sealed class <ladderClimbAnimation>d__7 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public PlayerControllerB playerController;

			public InteractTrigger ladder;

			public Vector3 ladderPosition;

			public Quaternion ladderAngle;

			private LethalBotAI <lethalBotAI>5__2;

			private float <timer>5__3;

			private int <finishClimbingLadder>5__4;

			private float <shorterWaitTime>5__5;

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

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

			[DebuggerHidden]
			public <ladderClimbAnimation>d__7(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<lethalBotAI>5__2 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_005f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0135: Unknown result type (might be due to invalid IL or missing references)
				//IL_013b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0161: Unknown result type (might be due to invalid IL or missing references)
				//IL_0181: Unknown result type (might be due to invalid IL or missing references)
				//IL_0187: Unknown result type (might be due to invalid IL or missing references)
				//IL_01ad: Unknown result type (might be due to invalid IL or missing references)
				//IL_05d4: Unknown result type (might be due to invalid IL or missing references)
				//IL_05da: Unknown result type (might be due to invalid IL or missing references)
				//IL_05fb: Unknown result type (might be due to invalid IL or missing references)
				//IL_061b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0621: Unknown result type (might be due to invalid IL or missing references)
				//IL_0642: Unknown result type (might be due to invalid IL or missing references)
				//IL_066c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0686: Unknown result type (might be due to invalid IL or missing references)
				//IL_06a7: Unknown result type (might be due to invalid IL or missing references)
				//IL_06d2: Unknown result type (might be due to invalid IL or missing references)
				//IL_028c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0291: Unknown result type (might be due to invalid IL or missing references)
				//IL_02fb: Unknown result type (might be due to invalid IL or missing references)
				//IL_0316: Unknown result type (might be due to invalid IL or missing references)
				//IL_023c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0771: Unknown result type (might be due to invalid IL or missing references)
				//IL_0348: Unknown result type (might be due to invalid IL or missing references)
				//IL_0363: Unknown result type (might be due to invalid IL or missing references)
				//IL_03ac: Unknown result type (might be due to invalid IL or missing references)
				//IL_03b1: Unknown result type (might be due to invalid IL or missing references)
				//IL_03f0: Unknown result type (might be due to invalid IL or missing references)
				//IL_03f5: Unknown result type (might be due to invalid IL or missing references)
				//IL_03fa: Unknown result type (might be due to invalid IL or missing references)
				//IL_040a: Unknown result type (might be due to invalid IL or missing references)
				//IL_040f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0414: Unknown result type (might be due to invalid IL or missing references)
				//IL_0424: Unknown result type (might be due to invalid IL or missing references)
				//IL_0429: Unknown result type (might be due to invalid IL or missing references)
				//IL_042e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0433: Unknown result type (might be due to invalid IL or missing references)
				//IL_0448: Unknown result type (might be due to invalid IL or missing references)
				//IL_044d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0452: Unknown result type (might be due to invalid IL or missing references)
				//IL_0462: Unknown result type (might be due to invalid IL or missing references)
				//IL_0467: Unknown result type (might be due to invalid IL or missing references)
				//IL_046c: Unknown result type (might be due to invalid IL or missing references)
				//IL_03d4: Unknown result type (might be due to invalid IL or missing references)
				//IL_03d9: Unknown result type (might be due to invalid IL or missing references)
				//IL_0520: Unknown result type (might be due to invalid IL or missing references)
				//IL_0525: Unknown result type (might be due to invalid IL or missing references)
				//IL_052a: Unknown result type (might be due to invalid IL or missing references)
				//IL_053a: Unknown result type (might be due to invalid IL or missing references)
				//IL_053f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0544: Unknown result type (might be due to invalid IL or missing references)
				//IL_0549: Unknown result type (might be due to invalid IL or missing references)
				//IL_0564: Unknown result type (might be due to invalid IL or missing references)
				//IL_0569: Unknown result type (might be due to invalid IL or missing references)
				//IL_0493: Unknown result type (might be due to invalid IL or missing references)
				//IL_0498: Unknown result type (might be due to invalid IL or missing references)
				//IL_049d: Unknown result type (might be due to invalid IL or missing references)
				//IL_04ad: Unknown result type (might be due to invalid IL or missing references)
				//IL_04b2: Unknown result type (might be due to invalid IL or missing references)
				//IL_04b7: Unknown result type (might be due to invalid IL or missing references)
				//IL_04bc: Unknown result type (might be due to invalid IL or missing references)
				//IL_04e5: Unknown result type (might be due to invalid IL or missing references)
				//IL_04ea: Unknown result type (might be due to invalid IL or missing references)
				//IL_04f0: Unknown result type (might be due to invalid IL or missing references)
				//IL_04f5: Unknown result type (might be due to invalid IL or missing references)
				//IL_04ff: Unknown result type (might be due to invalid IL or missing references)
				//IL_0504: Unknown result type (might be due to invalid IL or missing references)
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<lethalBotAI>5__2 = LethalBotManager.Instance.GetLethalBotAI(playerController);
					((UnityEvent<PlayerControllerB>)(object)ladder.onInteractEarly).Invoke((PlayerControllerB)null);
					playerController.UpdateSpecialAnimationValue(true, (short)ladder.ladderPlayerPositionNode.eulerAngles.y, 0f, true);
					playerController.enteringSpecialAnimation = true;
					playerController.inSpecialInteractAnimation = true;
					playerController.currentTriggerInAnimationWith = ladder;
					playerController.isCrouching = false;
					playerController.playerBodyAnimator.SetBool("crouching", false);
					playerController.playerBodyAnimator.SetTrigger("EnterLadder");
					((Collider)playerController.thisController).enabled = false;
					<timer>5__3 = 0f;
					goto IL_01b7;
				case 1:
					<>1__state = -1;
					<timer>5__3 += Time.deltaTime;
					playerController.thisPlayerBody.position = Vector3.Lerp(playerController.thisPlayerBody.position, ladderPosition, Mathf.SmoothStep(0f, 1f, <timer>5__3 / ladder.animationWaitTime));
					playerController.thisPlayerBody.rotation = Quaternion.Lerp(playerController.thisPlayerBody.rotation, ladderAngle, Mathf.SmoothStep(0f, 1f, <timer>5__3 / ladder.animationWaitTime));
					goto IL_01b7;
				case 2:
				{
					<>1__state = -1;
					bool? flag = <lethalBotAI>5__2?.NpcController.goDownLadder;
					if ((!flag.HasValue || flag.Value) && playerController.thisPlayerBody.position.y - 1f < ladder.bottomOfLadderPosition.position.y)
					{
						<finishClimbingLadder>5__4 = 1;
					}
					else if ((!flag.HasValue || !flag.Value) && playerController.thisPlayerBody.position.y + 2f > ladder.topOfLadderPosition.position.y)
					{
						<finishClimbingLadder>5__4 = 2;
					}
					goto IL_0376;
				}
				case 3:
					{
						<>1__state = -1;
						<timer>5__3 += Time.deltaTime;
						playerController.thisPlayerBody.position = Vector3.Lerp(playerController.thisPlayerBody.position, ladderPosition, Mathf.SmoothStep(0f, 1f, <timer>5__3 / <shorterWaitTime>5__5));
						playerController.thisPlayerBody.rotation = Quaternion.Lerp(playerController.thisPlayerBody.rotation, ladderAngle, Mathf.SmoothStep(0f, 1f, <timer>5__3 / <shorterWaitTime>5__5));
						((Component)playerController.gameplayCamera).transform.rotation = Quaternion.Slerp(((Component)playerController.gameplayCamera).transform.rotation, ((Component)playerController.gameplayCamera).transform.parent.rotation, Mathf.SmoothStep(0f, 1f, <timer>5__3 / <shorterWaitTime>5__5));
						break;
					}
					IL_01b7:
					if (<timer>5__3 <= ladder.animationWaitTime)
					{
						<>2__current = null;
						<>1__state = 1;
						return true;
					}
					Plugin.LogDebug("Finished snapping to ladder");
					playerController.playerBodyAnimator.SetBool("ClimbingLadder", true);
					playerController.isClimbingLadder = true;
					if ((Object)(object)<lethalBotAI>5__2 != (Object)null)
					{
						if (((EnemyAI)<lethalBotAI>5__2).agent.isOnOffMeshLink)
						{
							((EnemyAI)<lethalBotAI>5__2).agent.CompleteOffMeshLink();
						}
						<lethalBotAI>5__2.SetAgent(enabled: false);
						<lethalBotAI>5__2.TeleportLethalBot(ladderPosition, ((EnemyAI)<lethalBotAI>5__2).isOutside, null, withRotation: false, 0f, allowInteractTrigger: true, skipNavMeshCheck: true);
					}
					playerController.enteringSpecialAnimation = false;
					playerController.ladderCameraHorizontal = 0f;
					playerController.clampCameraRotation = ladder.bottomOfLadderPosition.eulerAngles;
					<finishClimbingLadder>5__4 = 0;
					goto IL_0376;
					IL_0376:
					if (<finishClimbingLadder>5__4 == 0)
					{
						<>2__current = null;
						<>1__state = 2;
						return true;
					}
					playerController.playerBodyAnimator.SetBool("ClimbingLadder", false);
					if (<finishClimbingLadder>5__4 == 1)
					{
						ladderPosition = ladder.bottomOfLadderPosition.position;
					}
					else if (!ladder.useRaycastToGetTopPosition)
					{
						ladderPosition = ladder.topOfLadderPosition.position;
					}
					else
					{
						Ray val = default(Ray);
						((Ray)(ref val))..ctor(((Component)playerController).transform.position + Vector3.up, ladder.topOfLadderPosition.position + Vector3.up - ((Component)playerController).transform.position + Vector3.up);
						RaycastHit val2 = default(RaycastHit);
						if (Physics.Linecast(((Component)playerController).transform.position + Vector3.up, ladder.topOfLadderPosition.position + Vector3.up, ref val2, StartOfRound.Instance.collidersAndRoomMaskAndDefault, (QueryTriggerInteraction)1))
						{
							Debug.DrawLine(((Component)playerController).transform.position + Vector3.up, ladder.topOfLadderPosition.position + Vector3.up, Color.red, 10f);
							ladderPosition = ((Ray)(ref val)).GetPoint(Mathf.Max(((RaycastHit)(ref val2)).distance - 1.2f, 0f));
							Debug.DrawRay(ladderPosition, Vector3.up * 0.5f, Color.yellow, 10f);
						}
						else
						{
							Debug.DrawLine(((Component)playerController).transform.position + Vector3.up, ladder.topOfLadderPosition.position + Vector3.up, Color.green, 10f);
							ladderPosition = ladder.topOfLadderPosition.position;
						}
					}
					<timer>5__3 = 0f;
					<shorterWaitTime>5__5 = ladder.animationWaitTime / 2f;
					break;
				}
				if (<timer>5__3 <= <shorterWaitTime>5__5)
				{
					<>2__current = null;
					<>1__state = 3;
					return true;
				}
				((Component)playerController.gameplayCamera).transform.localEulerAngles = Vector3.zero;
				Plugin.LogDebug("Finished ladder sequence");
				playerController.UpdateSpecialAnimationValue(false, (short)0, 0f, false);
				playerController.isClimbingLadder = false;
				playerController.inSpecialInteractAnimation = false;
				playerController.currentTriggerInAnimationWith = null;
				((Collider)playerController.thisController).enabled = true;
				if ((Object)(object)<lethalBotAI>5__2 != (Object)null)
				{
					if (((EnemyAI)<lethalBotAI>5__2).agent.isOnOffMeshLink)
					{
						((EnemyAI)<lethalBotAI>5__2).agent.CompleteOffMeshLink();
					}
					<lethalBotAI>5__2.SetAgent(enabled: true);
					<lethalBotAI>5__2.TeleportLethalBot(ladderPosition, ((EnemyAI)<lethalBotAI>5__2).isOutside, null, withRotation: false, 0f, allowInteractTrigger: true);
				}
				LethalBotAI lethalBotAI = <lethalBotAI>5__2;
				if (lethalBotAI != null)
				{
					lethalBotAI.useLadderCoroutine = null;
				}
				((UnityEvent<PlayerControllerB>)(object)ladder.onInteract).Invoke((PlayerControllerB)null);
				return false;
			}

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

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

		[CompilerGenerated]
		private sealed class <specialInteractAnimation>d__8 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public InteractTrigger trigger;

			public PlayerControllerB playerController;

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

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

			[DebuggerHidden]
			public <specialInteractAnimation>d__8(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_014f: Unknown result type (might be due to invalid IL or missing references)
				//IL_01d1: Unknown result type (might be due to invalid IL or missing references)
				//IL_01db: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					UpdateUsedByPlayerServerRpc_ReversePatch(trigger, (int)playerController.playerClientId);
					((UnityEvent<PlayerControllerB>)(object)trigger.onInteractEarly).Invoke((PlayerControllerB)null);
					trigger.isPlayingSpecialAnimation = true;
					playerScriptInSpecialAnimationField.SetValue(trigger, playerController);
					if (trigger.clampLooking)
					{
						playerController.minVerticalClamp = trigger.minVerticalClamp;
						playerController.maxVerticalClamp = trigger.maxVerticalClamp;
						playerController.horizontalClamp = trigger.horizontalClamp;
						playerController.clampLooking = true;
					}
					if (Object.op_Implicit((Object)(object)trigger.overridePlayerParent))
					{
						playerController.overridePhysicsParent = trigger.overridePlayerParent;
					}
					if (trigger.setVehicleAnimation)
					{
						playerController.inVehicleAnimation = true;
					}
					if (trigger.hidePlayerItem && (Object)(object)playerController.currentlyHeldObjectServer != (Object)null)
					{
						playerController.currentlyHeldObjectServer.EnableItemMeshes(false);
					}
					playerController.Crouch(false);
					playerController.UpdateSpecialAnimationValue(true, (short)trigger.playerPositionNode.eulerAngles.y, 0f, false);
					playerController.inSpecialInteractAnimation = true;
					playerController.currentTriggerInAnimationWith = trigger;
					playerController.playerBodyAnimator.ResetTrigger(trigger.animationString);
					playerController.playerBodyAnimator.SetTrigger(trigger.animationString);
					if (!trigger.stopAnimationManually)
					{
						<>2__current = (object)new WaitForSeconds(trigger.animationWaitTime);
						<>1__state = 1;
						return true;
					}
					break;
				case 1:
					<>1__state = -1;
					trigger.StopSpecialAnimation();
					break;
				}
				return false;
			}

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

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

		private static readonly FieldInfo lockedPlayerField = AccessTools.Field(typeof(InteractTrigger), "lockedPlayer");

		private static readonly FieldInfo hasTriggeredField = AccessTools.Field(typeof(InteractTrigger), "hasTriggered");

		private static readonly FieldInfo playerScriptInSpecialAnimationField = AccessTools.Field(typeof(InteractTrigger), "playerScriptInSpecialAnimation");

		private static readonly MethodInfo ladderPositionObstructedMethod = AccessTools.Method(typeof(InteractTrigger), "LadderPositionObstructed", (Type[])null, (Type[])null);

		[HarmonyPatch("StopUsingServerRpc")]
		[HarmonyReversePatch(/*Could not decode attribute arguments.*/)]
		[HarmonyPriority(0)]
		public static void StopUsingServerRpc_ReversePatch(object instance, int playerNum)
		{
			throw new NotImplementedException("Stub LethalBot.Patches.MapPatches.InteractTriggerPatch.StopUsingServerRpc_ReversePatch");
		}

		[HarmonyPatch("UpdateUsedByPlayerServerRpc")]
		[HarmonyReversePatch(/*Could not decode attribute arguments.*/)]
		[HarmonyPriority(0)]
		public static void UpdateUsedByPlayerServerRpc_ReversePatch(object instance, int playerNum)
		{
			throw new NotImplementedException("Stub LethalBot.Patches.MapPatches.InteractTriggerPatch.UpdateUsedByPlayerServerRpc_ReversePatch");
		}

		[HarmonyPatch("LadderPositionObstructed")]
		[HarmonyReversePatch(/*Could not decode attribute arguments.*/)]
		[HarmonyPriority(0)]
		public static bool LadderPositionObstructed_ReversePatch(object instance, PlayerControllerB playerController)
		{
			throw new NotImplementedException("Stub LethalBot.Patches.MapPatches.InteractTriggerPatch.LadderPositionObstructed_ReversePatch");
		}

		[IteratorStateMachine(typeof(<ladderClimbAnimation>d__7))]
		private static IEnumerator ladderClimbAnimation(InteractTrigger ladder, PlayerControllerB playerController, Vector3 ladderPosition, Quaternion ladderAngle)
		{
			//IL_0015: 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_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <ladderClimbAnimation>d__7(0)
			{
				ladder = ladder,
				playerController = playerController,
				ladderPosition = ladderPosition,
				ladderAngle = ladderAngle
			};
		}

		[IteratorStateMachine(typeof(<specialInteractAnimation>d__8))]
		private static IEnumerator specialInteractAnimation(InteractTrigger trigger, PlayerControllerB playerController)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <specialInteractAnimation>d__8(0)
			{
				trigger = trigger,
				playerController = playerController
			};
		}

		private static void CancelLadderAnimation(InteractTrigger ladder, PlayerControllerB playerController)
		{
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			LethalBotAI lethalBotAI = LethalBotManager.Instance.GetLethalBotAI(playerController);
			if ((Object)(object)lethalBotAI == (Object)null)
			{
				Plugin.LogWarning("Attempted to call custom CancelLadderAnimation on a human player!");
				return;
			}
			if (lethalBotAI.useLadderCoroutine != null)
			{
				((MonoBehaviour)ladder).StopCoroutine(lethalBotAI.useLadderCoroutine);
				lethalBotAI.useLadderCoroutine = null;
			}
			((UnityEvent<PlayerControllerB>)(object)ladder.onCancelAnimation).Invoke(playerController);
			playerController.currentTriggerInAnimationWith = null;
			playerController.isClimbingLadder = false;
			((Collider)playerController.thisController).enabled = true;
			playerController.playerBodyAnimator.SetBool("ClimbingLadder", false);
			((Component)playerController.gameplayCamera).transform.localEulerAngles = Vector3.zero;
			playerController.UpdateSpecialAnimationValue(false, (short)0, 0f, false);
			playerController.inSpecialInteractAnimation = false;
			ladder.currentCooldownValue = ladder.cooldownTime;
			if (ladder.hidePlayerItem && (Object)(object)playerController.currentlyHeldObjectServer != (Object)null)
			{
				playerController.currentlyHeldObjectServer.EnableItemMeshes(true);
			}
			((UnityEvent<PlayerControllerB>)(object)ladder.onInteract).Invoke((PlayerControllerB)null);
		}

		[HarmonyPatch("Interact")]
		[HarmonyPrefix]
		public static bool Interact_Prefix(InteractTrigger __instance, Transform playerTransform, ref bool ___hasTriggered)
		{
			//IL_018d: Unknown result type (might be due to invalid IL or missing references)
			//IL_019d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01de: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0212: Unknown result type (might be due to invalid IL or missing references)
			//IL_0214: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)playerTransform == (Object)null || (Object)(object)playerTransform == (Object)(object)((Component)GameNetworkManager.Instance.localPlayerController).transform)
			{
				Plugin.LogDebug("Default interact called! Player is local playerController!");
				return true;
			}
			PlayerControllerB component = ((Component)playerTransform).GetComponent<PlayerControllerB>();
			LethalBotAI lethalBotAI = LethalBotManager.Instance.GetLethalBotAI(component);
			if ((Object)(object)lethalBotAI == (Object)null)
			{
				Plugin.LogDebug("Default interact called! Player is not a bot!");
				return true;
			}
			Plugin.LogDebug("Custom interact called! Player is a bot!");
			if ((__instance.triggerOnce & ___hasTriggered) || StartOfRound.Instance.firingPlayersCutsceneRunning)
			{
				return false;
			}
			___hasTriggered = true;
			if (__instance.RandomChanceTrigger && Random.Range(0, 101) > __instance.randomChancePercentage)
			{
				return false;
			}
			if (!__instance.interactable || __instance.isPlayingSpecialAnimation || lethalBotAI.useLadderCoroutine != null)
			{
				if (lethalBotAI.useLadderCoroutine != null)
				{
					CancelLadderAnimation(__instance, component);
				}
				return false;
			}
			if (component.inSpecialInteractAnimation && !component.isClimbingLadder && !__instance.allowUseWhileInAnimation)
			{
				return false;
			}
			if (__instance.interactCooldown)
			{
				if (__instance.currentCooldownValue >= 0f)
				{
					return false;
				}
				__instance.currentCooldownValue = __instance.cooldownTime;
				if ((lethalBotAI.State?.LethalBotInteraction?.isBeingHeldByPlayer).GetValueOrDefault())
				{
					AIState state = lethalBotAI.State;
					if (state != null)
					{
						LethalBotInteraction? lethalBotInteraction = state.LethalBotInteraction;
						if (lethalBotInteraction != null)
						{
							lethalBotInteraction.isBeingHeldByPlayer = false;
						}
					}
				}
			}
			if (!__instance.specialCharacterAnimation && !__instance.isLadder)
			{
				((UnityEvent<PlayerControllerB>)(object)__instance.onInteract).Invoke(component);
				return false;
			}
			component.ResetFallGravity();
			if (__instance.isLadder)
			{
				Vector3 ladderPosition = default(Vector3);
				((Vector3)(ref ladderPosition))..ctor(__instance.ladderHorizontalPosition.position.x, Mathf.Clamp(component.thisPlayerBody.position.y, __instance.bottomOfLadderPosition.position.y + 0.3f, __instance.topOfLadderPosition.position.y - 2.2f), __instance.ladderHorizontalPosition.position.z);
				Quaternion rotation = __instance.ladderPlayerPositionNode.rotation;
				if (lethalBotAI.useLadderCoroutine != null)
				{
					((MonoBehaviour)__instance).StopCoroutine(lethalBotAI.useLadderCoroutine);
				}
				lethalBotAI.useLadderCoroutine = ((MonoBehaviour)__instance).StartCoroutine(ladderClimbAnimation(__instance, component, ladderPosition, rotation));
			}
			else
			{
				((MonoBehaviour)__instance).StartCoroutine(specialInteractAnimation(__instance, component));
			}
			return false;
		}

		[HarmonyPatch("StopSpecialAnimation")]
		[HarmonyPrefix]
		public static bool StopSpecialAnimation_Prefix(InteractTrigger __instance, ref Transform ___lockedPlayer)
		{
			//IL_01a8: Unknown result type (might be due to invalid IL or missing references)
			Transform val = ___lockedPlayer;
			Transform obj = val;
			GameNetworkManager instance = GameNetworkManager.Instance;
			object obj2;
			if (instance == null)
			{
				obj2 = null;
			}
			else
			{
				PlayerControllerB localPlayerController = instance.localPlayerController;
				obj2 = ((localPlayerController != null) ? ((Component)localPlayerController).transform : null);
			}
			if ((Object)(object)obj == (Object)obj2)
			{
				Plugin.LogDebug($"Default stop special animation called! Player {val} is local playerController!");
				return true;
			}
			PlayerControllerB val2 = ((val != null) ? ((Component)val).GetComponent<PlayerControllerB>() : null);
			if ((Object)(object)val2 != (Object)null && !LethalBotManager.Instance.IsPlayerLethalBot(val2))
			{
				Plugin.LogDebug($"Default stop special animation called! Player {val} is not a bot!");
				return true;
			}
			LethalBotAI lethalBotAI = null;
			PlayerControllerB[] allPlayerScripts = StartOfRound.Instance.allPlayerScripts;
			foreach (PlayerControllerB val3 in allPlayerScripts)
			{
				LethalBotAI lethalBotAI2 = LethalBotManager.Instance.GetLethalBotAI(val3);
				if ((Object)(object)lethalBotAI2 != (Object)null && (val3.isPlayerControlled || val3.isPlayerDead) && (Object)(object)val3.currentTriggerInAnimationWith == (Object)(object)__instance)
				{
					lethalBotAI = lethalBotAI2;
					val2 = val3;
					val = ((Component)val3).transform;
					break;
				}
			}
			if ((Object)(object)lethalBotAI == (Object)null || (Object)(object)val2 == (Object)null)
			{
				return false;
			}
			Plugin.LogDebug($"Stop special animation on {((Object)((Component)__instance).gameObject).name}, by {val}; {val2}");
			if (__instance.isPlayingSpecialAnimation && __instance.stopAnimationManually && (Object)(object)val != (Object)null)
			{
				Plugin.LogDebug($"Calling stop animation function StopUsing server rpc for playerController: {val2.playerClientId}");
				StopUsingServerRpc_ReversePatch(__instance, (int)val2.playerClientId);
			}
			if ((Object)(object)val2 != (Object)null)
			{
				((UnityEvent<PlayerControllerB>)(object)__instance.onCancelAnimation).Invoke(val2);
				if (__instance.hidePlayerItem && (Object)(object)val2.currentlyHeldObjectServer != (Object)null)
				{
					val2.currentlyHeldObjectServer.EnableItemMeshes(true);
				}
				__instance.isPlayingSpecialAnimation = false;
				val2.inSpecialInteractAnimation = false;
				if (val2.clampLooking)
				{
					((Component)val2.gameplayCamera).transform.localEulerAngles = Vector3.zero;
				}
				val2.clampLooking = false;
				val2.inVehicleAnimation = false;
				if (Object.op_Implicit((Object)(object)__instance.overridePlayerParent) && (Object)(object)val2.overridePhysicsParent == (Object)(object)__instance.overridePlayerParent)
				{
					val2.overridePhysicsParent = null;
				}
				val2.currentTriggerInAnimationWith = null;
				if (val2.isClimbingLadder)
				{
					CancelLadderAnimation(__instance, val2);
					val2.isClimbingLadder = false;
				}
				Plugin.LogDebug("Stop special animation F");
				if (__instance.stopAnimationManually)
				{
					val2.playerBodyAnimator.SetTrigger(__instance.stopAnimationString);
				}
				val2.UpdateSpecialAnimationValue(false, (short)0, 0f, false);
				__instance.currentCooldownValue = __instance.cooldownTime;
				((UnityEvent<PlayerControllerB>)(object)__instance.onInteract).Invoke((PlayerControllerB)null);
				Plugin.LogDebug("Stop special animation G");
				lethalBotAI.State?.LethalBotInteraction?.StopHoldInteractionOnTrigger();
				if (lethalBotAI.useInteractTriggerCoroutine != null)
				{
					((MonoBehaviour)lethalBotAI).StopCoroutine(lethalBotAI.useInteractTriggerCoroutine);
				}
				lethalBotAI.useInteractTriggerCoroutine = null;
			}
			return false;
		}
	}
	[HarmonyPatch(typeof(OutOfBoundsTrigger))]
	public class OutOfBoundsTriggerPatch
	{
		[HarmonyPatch("OnTriggerEnter")]
		[HarmonyPostfix]
		private static void OnTriggerEnter_Postfix(OutOfBoundsTrigger __instance, Collider other, StartOfRound ___playersManager)
		{
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_028b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0267: Unknown result type (might be due to invalid IL or missing references)
			//IL_024b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0255: Unknown result type (might be due to invalid IL or missing references)
			//IL_025b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0206: Unknown result type (might be due to invalid IL or missing references)
			//IL_020b: Unknown result type (might be due to invalid IL or missing references)
			//IL_020f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0214: Unknown result type (might be due to invalid IL or missing references)
			//IL_0216: Unknown result type (might be due to invalid IL or missing references)
			//IL_021b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0224: Unknown result type (might be due to invalid IL or missing references)
			//IL_0229: Unknown result type (might be due to invalid IL or missing references)
			//IL_022b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: Unknown result type (might be due to invalid IL or missing references)
			//IL_0139: Unknown result type (might be due to invalid IL or missing references)
			//IL_014c: Unknown result type (might be due to invalid IL or missing references)
			//IL_015d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0162: Unknown result type (might be due to invalid IL or missing references)
			//IL_0166: Unknown result type (might be due to invalid IL or missing references)
			//IL_016b: Unknown result type (might be due to invalid IL or missing references)
			//IL_016d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0172: Unknown result type (might be due to invalid IL or missing references)
			//IL_017c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0181: Unknown result type (might be due to invalid IL or missing references)
			//IL_0183: Unknown result type (might be due to invalid IL or missing references)
			if ((__instance.disableWhenRoundStarts && !___playersManager.inShipPhase) || ((Component)other).tag.StartsWith("PlayerRagdoll") || !(((Component)other).tag == "Player"))
			{
				return;
			}
			PlayerControllerB component = ((Component)other).GetComponent<PlayerControllerB>();
			LethalBotAI lethalBotAIIfLocalIsOwner = LethalBotManager.Instance.GetLethalBotAIIfLocalIsOwner(component);
			if ((Object)(object)lethalBotAIIfLocalIsOwner == (Object)null)
			{
				return;
			}
			component.ResetFallGravity();
			if ((Object)(object)component == (Object)null)
			{
				return;
			}
			if (!___playersManager.shipDoorsEnabled)
			{
				component.isInElevator = true;
				component.isInHangarShipRoom = true;
				((EnemyAI)lethalBotAIIfLocalIsOwner).isInsidePlayerShip = true;
				Vector3 playerSpawnPosition_ReversePatch = StartOfRoundPatch.GetPlayerSpawnPosition_ReversePatch(StartOfRound.Instance, (int)component.playerClientId, simpleTeleport: false);
				((Collider)component.thisController).enabled = false;
				component.TeleportPlayer(playerSpawnPosition_ReversePatch, false, 0f, false, true);
				component.serverPlayerPosition = playerSpawnPosition_ReversePatch;
				((Component)component).transform.localPosition = playerSpawnPosition_ReversePatch;
				((Component)component).transform.position = playerSpawnPosition_ReversePatch;
				((Collider)component.thisController).enabled = true;
				GrabbableObject[] itemSlots = component.ItemSlots;
				foreach (GrabbableObject val in itemSlots)
				{
					Transform val2 = val?.parentObject;
					if ((Object)(object)val != (Object)null && (Object)(object)val2 != (Object)null)
					{
						((Component)val).transform.rotation = val2.rotation;
						((Component)val).transform.Rotate(val.itemProperties.rotationOffset);
						((Component)val).transform.position = val2.position;
						Vector3 positionOffset = val.itemProperties.positionOffset;
						positionOffset = val2.rotation * positionOffset;
						Transform transform = ((Component)val).transform;
						transform.position += positionOffset;
					}
				}
				GrabbableObject itemOnlySlot = component.ItemOnlySlot;
				if ((Object)(object)itemOnlySlot != (Object)null)
				{
					Transform parentObject = itemOnlySlot.parentObject;
					if ((Object)(object)parentObject != (Object)null)
					{
						((Component)itemOnlySlot).transform.rotation = parentObject.rotation;
						((Component)itemOnlySlot).transform.Rotate(itemOnlySlot.itemProperties.rotationOffset);
						((Component)itemOnlySlot).transform.position = parentObject.position;
						Vector3 positionOffset2 = itemOnlySlot.itemProperties.positionOffset;
						positionOffset2 = parentObject.rotation * positionOffset2;
						Transform transform2 = ((Component)itemOnlySlot).transform;
						transform2.position += positionOffset2;
					}
				}
			}
			else if (component.isInsideFactory)
			{
				if (!StartOfRound.Instance.isChallengeFile)
				{
					component.KillPlayer(Vector3.zero, false, (CauseOfDeath)0, 0, default(Vector3), false);
				}
				else
				{
					component.TeleportPlayer(RoundManager.FindMainEntrancePosition(true, false), false, 0f, false, true);
				}
			}
			else if (component.isInHangarShipRoom)
			{
				component.TeleportPlayer(___playersManager.playerSpawnPositions[0].position, false, 0f, false, true);
			}
			else
			{
				component.TeleportPlayer(___playersManager.outsideShipSpawnPosition.position, false, 0f, false, true);
			}
		}
	}
	[HarmonyPatch(typeof(ShipTeleporter))]
	public class ShipTeleporterPatch
	{
		[HarmonyPatch("SetPlayerTeleporterId")]
		[HarmonyPrefix]
		private static void SetPlayerTeleporterId_PreFix(PlayerControllerB playerScript, int teleporterId)
		{
			LethalBotAI lethalBotAI = LethalBotManager.Instance.GetLethalBotAI(playerScript);
			if (!((Object)(object)lethalBotAI == (Object)null) && !((EnemyAI)lethalBotAI).isEnemyDead && !playerScript.isPlayerDead && playerScript.shipTeleporterId == 1 && teleporterId == -1)
			{
				playerScript.ResetFallGravity();
				lethalBotAI.InitStateToSearchingNoTarget();
				playerScript.parentedToElevatorLastFrame = true;
				lethalBotAI.ReParentLethalBot(playerScript.playersManager.elevatorTransform);
			}
		}

		[HarmonyPatch("beamOutPlayer")]
		[HarmonyPostfix]
		private static void beamOutPlayer_PostFix(ShipTeleporter __instance, Random ___shipTeleporterSeed)
		{
			LethalBotManager.Instance.TeleportOutLethalBots(__instance, ___shipTeleporterSeed);
		}

		[HarmonyPatch("TeleportPlayerOutWithInverseTeleporter")]
		[HarmonyPostfix]
		private static void TeleportPlayerOutWithInverseTeleporter_PostFix(ShipTeleporter __instance, int playerObj)
		{
			LethalBotAI lethalBotAIIfLocalIsOwner = LethalBotManager.Instance.GetLethalBotAIIfLocalIsOwner(playerObj);
			if ((Object)(object)lethalBotAIIfLocalIsOwner != (Object)null)
			{
				lethalBotAIIfLocalIsOwner.InitStateToSearchingNoTarget(isInverseTeleport: true);
			}
		}

		[HarmonyPatch(/*Could not decode attribute arguments.*/)]
		[HarmonyTranspiler]
		public static IEnumerable<CodeInstruction> beamUpPlayer_Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator generator)
		{
			int num = -1;
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			MethodInfo methodInfo = AccessTools.PropertyGetter(typeof(GameNetworkManager), "Instance");
			FieldInfo fieldInfo = AccessTools.Field(typeof(GameNetworkManager), "localPlayerController");
			MethodInfo methodInfo2 = AccessTools.Method(typeof(Object), "op_Equality", (Type[])null, (Type[])null);
			for (int i = 0; i < list.Count - 4; i++)
			{
				if (list[i].opcode == OpCodes.Ldfld && list[i].operand is FieldInfo fieldInfo2 && fieldInfo2.Name.Contains("playerToBeamUp") && CodeInstructionExtensions.Calls(list[i + 1], methodInfo) && CodeInstructionExtensions.LoadsField(list[i + 2], fieldInfo, false) && CodeInstructionExtensions.Calls(list[i + 3], methodInfo2))
				{
					num = i;
					break;
				}
			}
			if (num > -1)
			{
				list[num + 1].opcode = OpCodes.Nop;
				list[num + 1].operand = null;
				list[num + 2].opcode = OpCodes.Nop;
				list[num + 2].operand = null;
				list[num + 3].opcode = OpCodes.Call;
				list[num + 3].operand = PatchesUtil.IsPlayerLocalOrLethalBotOwnerLocalMethod;
				num = -1;
			}
			else
			{
				Plugin.LogError("LethalBot.Patches.MapPatches.ShipTeleporterPatch.beamUpPlayer_Transpiler could not make bots drop their held items when teleported");
			}
			return list.AsEnumerable();
		}

		[HarmonyPatch("SetPlayerTeleporterId")]
		[HarmonyReversePatch(/*Could not decode attribute arguments.*/)]
		[HarmonyPriority(0)]
		public static void SetPlayerTeleporterId_ReversePatch(object instance, PlayerControllerB playerScript, int teleporterId)
		{
			throw new NotImplementedException("Stub LethalBot.Patches.MapPatches.ShipTeleporterPatch.SetPlayerTeleporterId_ReversePatch");
		}

		[HarmonyPatch("TeleportPlayerOutWithInverseTeleporter")]
		[HarmonyReversePatch(/*Could not decode attribute arguments.*/)]
		[HarmonyPriority(0)]
		public static void TeleportPlayerOutWithInverseTeleporter_ReversePatch(object instance, int playerObj, Vector3 teleportPos)
		{
			throw new NotImplementedException("Stub LethalBot.Patches.MapPatches.ShipTeleporterPatch.TeleportPlayerOutWithInverseTeleporter_ReversePatch");
		}

		[HarmonyPatch("GetInverseTelePosition")]
		[HarmonyReversePatch(/*Could not decode attribute arguments.*/)]
		[HarmonyPriority(0)]
		public static Vector3 GetInverseTelePosition_ReversePatch(object instance)
		{
			throw new NotImplementedException("Stub LethalBot.Patches.MapPatches.ShipTeleporterPatch.GetInverseTelePosition_ReversePatch");
		}
	}
	[HarmonyPatch(typeof(VehicleController))]
	public class VehicleControllerPatch
	{
		[HarmonyPatch("Start")]
		[HarmonyFinalizer]
		private static Exception Start_Finalizer(Exception __exception)
		{
			LethalBotManager.Instance.VehicleHasLanded();
			return __exception;
		}

		[HarmonyPatch("Start")]
		[HarmonyPostfix]
		private static void Start_PostFix()
		{
			LethalBotManager.Instance.VehicleHasLanded();
		}

		[HarmonyPatch("DamagePlayerInVehicle")]
		[HarmonyPostfix]
		private static void DamagePlayerInVehicle_PostFix(VehicleController __instance, Vector3 vel, float magnitude)
		{
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			LethalBotAI[] lethalBotsAIOwnedByLocal = LethalBotManager.Instance.GetLethalBotsAIOwnedByLocal();
			LethalBotAI[] array = lethalBotsAIOwnedByLocal;
			foreach (LethalBotAI lethalBotAI in array)
			{
				PlayerControllerB npc = lethalBotAI.NpcController.Npc;
				if (!__instance.localPlayerInPassengerSeat && !__instance.localPlayerInControl)
				{
					if ((Object)(object)__instance.physicsRegion.physicsTransform == (Object)(object)npc.physicsParent && (Object)(object)npc.overridePhysicsParent == (Object)null)
					{
						npc.DamagePlayer(10, true, true, (CauseOfDeath)16, 0, false, vel);
						npc.externalForceAutoFade += vel;
					}
					break;
				}
				if (magnitude > 28f)
				{
					npc.KillPlayer(vel, true, (CauseOfDeath)16, 0, ((Component)__instance).transform.up * 0.77f, false);
					break;
				}
				if (magnitude <= 24f)
				{
					npc.DamagePlayer(30, true, true, (CauseOfDeath)16, 0, false, vel);
					break;
				}
				if (npc.health < 20)
				{
					npc.KillPlayer(vel, true, (CauseOfDeath)16, 0, ((Component)__instance).transform.up * 0.77f, false);
					break;
				}
				npc.DamagePlayer(40, true, true, (CauseOfDeath)16, 0, false, vel);
			}
		}
	}
}
namespace LethalBots.Patches.MapHazardsPatches
{
	[HarmonyPatch(typeof(Landmine))]
	public class LandminePatch
	{
		[HarmonyPatch("OnTriggerEnter")]
		[HarmonyPrefix]
		private static bool OnTriggerEnter_PreFix(ref Landmine __instance, Collider other, ref bool ___localPlayerOnMine, ref float ___pressMineDebounceTimer)
		{
			if (__instance.hasExploded)
			{
				return true;
			}
			if (___pressMineDebounceTimer > 0f)
			{
				return true;
			}
			PlayerControllerB component = ((Component)other).gameObject.GetComponent<PlayerControllerB>();
			if ((Object)(object)component != (Object)null && !component.isPlayerDead)
			{
				LethalBotAI lethalBotAIIfLocalIsOwner = LethalBotManager.Instance.GetLethalBotAIIfLocalIsOwner(component);
				if ((Object)(object)lethalBotAIIfLocalIsOwner != (Object)null)
				{
					___localPlayerOnMine = true;
					___pressMineDebounceTimer = 0.5f;
					__instance.PressMineServerRpc();
					lethalBotAIIfLocalIsOwner.LethalBotIdentity.Voice.TryPlayVoiceAudio(new PlayVoiceParameters
					{
						VoiceState = EnumVoicesState.SteppedOnTrap,
						CanTalkIfOtherLethalBotTalk = true,
						WaitForCooldown = false,
						CutCurrentVoiceStateToTalk = true,
						CanRepeatVoiceState = false,
						ShouldSync = false,
						IsLethalBotInside = component.isInsideFactory,
						AllowSwearing = Plugin.Config.AllowSwearing.Value
					});
					return false;
				}
			}
			return true;
		}

		[HarmonyPatch("OnTriggerExit")]
		[HarmonyPrefix]
		private static bool OnTriggerExit_PreFix(ref Landmine __instance, Collider other, ref bool ___localPlayerOnMine, bool ___mineActivated)
		{
			if (__instance.hasExploded)
			{
				return true;
			}
			if (!___mineActivated)
			{
				return true;
			}
			PlayerControllerB component = ((Component)other).gameObject.GetComponent<PlayerControllerB>();
			if ((Object)(object)component != (Object)null && !component.isPlayerDead)
			{
				LethalBotAI lethalBotAIIfLocalIsOwner = LethalBotManager.Instance.GetLethalBotAIIfLocalIsOwner(component);
				if ((Object)(object)lethalBotAIIfLocalIsOwner != (Object)null)
				{
					___localPlayerOnMine = false;
					lethalBotAIIfLocalIsOwner.LethalBotIdentity.Voice.TryPlayVoiceAudio(new PlayVoiceParameters
					{
						VoiceState = EnumVoicesState.SteppedOnTrap,
						CanTalkIfOtherLethalBotTalk = true,
						WaitForCooldown = false,
						CutCurrentVoiceStateToTalk = true,
						CanRepeatVoiceState = true,
						ShouldSync = false,
						IsLethalBotInside = component.isInsideFactory,
						AllowSwearing = Plugin.Config.AllowSwearing.Value
					});
					TriggerMineOnLocalClientByExiting_ReversePatch(__instance);
					return false;
				}
			}
			return true;
		}

		[HarmonyPatch("TriggerMineOnLocalClientByExiting")]
		[HarmonyReversePatch(/*Could not decode attribute arguments.*/)]
		[HarmonyPriority(0)]
		public static void TriggerMineOnLocalClientByExiting_ReversePatch(object instance)
		{
			throw new NotImplementedException("Stub LethalBot.Patches.EnemiesPatches.TriggerMineOnLocalClientByExiting");
		}

		[HarmonyPatch("SpawnExplosion")]
		[HarmonyPostfix]
		private static void SpawnExplosion_PostFix(Vector3 explosionPosition, float killRange, float damageRange, int nonLethalDamage, float physicsForce, bool goThroughCar)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_0133: Unknown result type (might be due to invalid IL or missing references)
			//IL_0138: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0143: Unknown result type (might be due to invalid IL or missing references)
			//IL_0170: Unknown result type (might be due to invalid IL or missing references)
			//IL_0177: Unknown result type (might be due to invalid IL or missing references)
			//IL_017d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0206: Unknown result type (might be due to invalid IL or missing references)
			//IL_020b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0215: Unknown result type (might be due to invalid IL or missing references)
			//IL_021a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0197: Unknown result type (might be due to invalid IL or missing references)
			//IL_019c: Unknown result type (might be due to invalid IL or missing references)
			//IL_019d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_023b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0240: Unknown result type (might be due to invalid IL or missing references)
			//IL_0247: Unknown result type (might be due to invalid IL or missing references)
			//IL_024c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0251: Unknown result type (might be due to invalid IL or missing references)
			//IL_0252: Unknown result type (might be due to invalid IL or missing references)
			//IL_0257: Unknown result type (might be due to invalid IL or missing references)
			//IL_0264: Unknown result type (might be due to invalid IL or missing references)
			//IL_026b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0270: Unknown result type (might be due to invalid IL or missing references)
			//IL_02dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02cb: Unknown result type (might be due to invalid IL or missing references)
			Collider[] array = Physics.OverlapSphere(explosionPosition, damageRange, 8, (QueryTriggerInteraction)2);
			HashSet<ulong> hashSet = new HashSet<ulong>();
			RaycastHit val2 = default(RaycastHit);
			RaycastHit val6 = default(RaycastHit);
			for (int i = 0; i < array.Length; i++)
			{
				Collider val = array[i];
				Plugin.LogDebug($"SpawnExplosion OverlapSphere array {i} {((Object)val).name}");
				float num = Vector3.Distance(explosionPosition, ((Component)val).transform.position);
				PlayerControllerB component = ((Component)val).gameObject.GetComponent<PlayerControllerB>();
				if ((Object)(object)component == (Object)null || hashSet.Contains(component.playerClientId))
				{
					continue;
				}
				LethalBotAI lethalBotAIIfLocalIsOwner = LethalBotManager.Instance.GetLethalBotAIIfLocalIsOwner(component);
				if ((Object)(object)lethalBotAIIfLocalIsOwner == (Object)null || (Physics.Linecast(explosionPosition, ((Component)val).transform.position + Vector3.up * 0.3f, ref val2, 1073742080, (QueryTriggerInteraction)1) && ((!goThroughCar && ((Component)((RaycastHit)(ref val2)).collider).gameObject.layer == 30) || num > 4f)))
				{
					continue;
				}
				Vector3 val4;
				if (((Component)val).gameObject.layer == 3)
				{
					if (num < killRange)
					{
						Vector3 val3 = Vector3.Normalize(((Component)component.gameplayCamera).transform.position - explosionPosition) * 80f / Vector3.Distance(((Component)component.gameplayCamera).transform.position, explosionPosition);
						Plugin.LogDebug($"SyncKillLethalBot from explosion for LOCAL client #{((NetworkBehaviour)lethalBotAIIfLocalIsOwner).NetworkManager.LocalClientId}, lethalBot object: Bot #{lethalBotAIIfLocalIsOwner.BotId}");
						val4 = default(Vector3);
						component.KillPlayer(val3, true, (CauseOfDeath)3, 0, val4, false);
					}
					else if (num < damageRange)
					{
						Vector3 val5 = Vector3.Normalize(((Component)component.gameplayCamera).transform.position - explosionPosition) * 80f / Vector3.Distance(((Component)component.gameplayCamera).transform.position, explosionPosition);
						component.DamagePlayer(nonLethalDamage, true, true, (CauseOfDeath)3, 0, false, val5 * 0.6f);
					}
				}
				if (physicsForce > 0f && num < 35f && !Physics.Linecast(explosionPosition, ((Component)val).transform.position + Vector3.up * 0.3f, ref val6, 256, (QueryTriggerInteraction)1))
				{
					float num2 = num;
					Vector3 val7 = Vector3.Normalize(((Component)component).transform.position + Vector3.up * num2 - explosionPosition) / (num2 * 0.35f) * physicsForce;
					Plugin.LogDebug($"Physics Force is {physicsForce}. Calculated Force is {((Vector3)(ref val7)).magnitude}!");
					if (((Vector3)(ref val7)).sqrMagnitude > 4f)
					{
						if (((Vector3)(ref val7)).sqrMagnitude > 100f)
						{
							component.CancelSpecialTriggerAnimations();
						}
						if (component.inVehicleAnimation)
						{
							val4 = component.externalForceAutoFade + val7;
							if (!(((Vector3)(ref val4)).sqrMagnitude > 2500f))
							{
								goto IL_02ee;
							}
						}
						component.externalForceAutoFade += val7;
					}
				}
				goto IL_02ee;
				IL_02ee:
				hashSet.Add(component.playerClientId);
			}
		}

		[HarmonyPatch("SpawnExplosion")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> SpawnExplosion_Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator generator)
		{
			int num = -1;
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			MethodInfo methodInfo = AccessTools.PropertyGetter(typeof(NetworkBehaviour), "IsOwner");
			Plugin.LogDebug("Beginning to patch Landmine.SpawnExplosion!");
			for (int i = 0; i < list.Count; i++)
			{
				if (CodeInstructionExtensions.Calls(list[i], methodInfo))
				{
					num = i;
					break;
				}
			}
			if (num != -1)
			{
				list[num].opcode = OpCodes.Call;
				list[num].operand = PatchesUtil.IsPlayerLocalMethod;
				num = -1;
			}
			else
			{
				Plugin.LogError("LethalBot.Patches.MapHazardsPatches.Landmine.SpawnExplosion_Transpiler could not find the IsOwner call!");
			}
			Plugin.LogDebug("Finished patching Landmine.SpawnExplosion!");
			return list.AsEnumerable();
		}
	}
	[HarmonyPatch(typeof(QuicksandTrigger))]
	public class QuicksandTriggerPatch
	{
		[HarmonyPatch("OnTriggerStay")]
		[HarmonyPostfix]
		public static void OnTriggerStay_Postfix(ref QuicksandTrigger __instance, Collider other)
		{
			PlayerControllerB component = ((Component)other).gameObject.GetComponent<PlayerControllerB>();
			if ((Object)(object)component == (Object)null)
			{
				return;
			}
			LethalBotAI lethalBotAI = LethalBotManager.Instance.GetLethalBotAI(component);
			if ((Object)(object)lethalBotAI == (Object)null || lethalBotAI.NpcController.IsControllerInCruiser)
			{
				return;
			}
			if (__instance.isWater && (Object)(object)component.underwaterCollider == (Object)null)
			{
				component.underwaterCollider = ((Component)__instance).gameObject.GetComponent<Collider>();
			}
			component.statusEffectAudioIndex = __instance.audioClipIndex;
			if (component.isSinking)
			{
				if (!__instance.isWater)
				{
					lethalBotAI.LethalBotIdentity.Voice.TryPlayVoiceAudio(new PlayVoiceParameters
					{
						VoiceState = EnumVoicesState.Sinking,
						CanTalkIfOtherLethalBotTalk = true,
						WaitForCooldown = false,
						CutCurrentVoiceStateToTalk = true,
						CanRepeatVoiceState = true,
						ShouldSync = false,
						IsLethalBotInside = lethalBotAI.NpcController.Npc.isInsideFactory,
						AllowSwearing = Plugin.Config.AllowSwearing.Value
					});
				}
			}
			else if (lethalBotAI.NpcController.CheckConditionsForSinkingInQuicksandLethalBot())
			{
				component.sourcesCausingSinking++;
				component.isMovementHindered++;
				Plugin.LogDebug($"playerScript {component.playerClientId} ++isMovementHindered {component.isMovementHindered}");
				component.hinderedMultiplier *= __instance.movementHinderance;
				if (__instance.isWater)
				{
					component.sinkingSpeedMultiplier = 0f;
				}
				else
				{
					component.sinkingSpeedMultiplier = __instance.sinkingSpeedMultiplier;
				}
			}
			else
			{
				lethalBotAI.StopSinkingState();
			}
		}

		[HarmonyPatch("OnExit")]
		[HarmonyPostfix]
		public static void OnExit_Postfix(ref QuicksandTrigger __instance, Collider other)
		{
			PlayerControllerB component = ((Component)other).gameObject.GetComponent<PlayerControllerB>();
			if (!((Object)(object)component == (Object)null))
			{
				LethalBotAI lethalBotAI = LethalBotManager.Instance.GetLethalBotAI(component);
				if (!((Object)(object)lethalBotAI == (Object)null) && !lethalBotAI.NpcController.IsControllerInCruiser)
				{
					lethalBotAI.StopSinkingState();
				}
			}
		}

		[HarmonyPatch("StopSinkingLocalPlayer")]
		[HarmonyPrefix]
		public static bool StopSinkingLocalPlayer_Prefix(QuicksandTrigger __instance, PlayerControllerB playerScript)
		{
			LethalBotAI lethalBotAIIfLocalIsOwner = LethalBotManager.Instance.GetLethalBotAIIfLocalIsOwner(playerScript);
			if ((Object)(object)lethalBotAIIfLocalIsOwner == (Object)null)
			{
				return true;
			}
			lethalBotAIIfLocalIsOwner.StopSinkingState();
			return false;
		}
	}
	[HarmonyPatch(typeof(SpikeRoofTrap))]
	public class SpikeRoofTrapPatch
	{
		[HarmonyPatch("OnTriggerStay")]
		[HarmonyPostfix]
		private static void OnTriggerStay_PostFix(SpikeRoofTrap __instance, Collider other)
		{
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			if (__instance.trapActive && __instance.slammingDown && !(Time.realtimeSinceStartup - __instance.timeSinceMovingUp < 0.75f))
			{
				PlayerControllerB component = ((Component)other).gameObject.GetComponent<PlayerControllerB>();
				if ((Object)(object)component != (Object)null && LethalBotManager.Instance.IsPlayerLethalBotOwnerLocal(component) && !component.isPlayerDead)
				{
					component.KillPlayer(Vector3.down * 17f, true, (CauseOfDeath)8, 0, default(Vector3), false);
				}
			}
		}
	}
	[HarmonyPatch(typeof(Turret))]
	public class TurretPatch
	{
		private static MethodInfo DamagePlayersInLOSMethod = SymbolExtensions.GetMethodInfo(Expression.Lambda<Action>(Expression.Call(null, (MethodInfo)MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), Expression.New(typeof(Turret))), Array.Empty<ParameterExpression>()));

		[HarmonyPatch("Update")]
		[HarmonyTranspiler]
		public static IEnumerable<CodeInstruction> Update_Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator generator)
		{
			int num = -1;
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			MethodInfo methodInfo = AccessTools.Method(typeof(Turret), "CheckForPlayersInLineOfSight", (Type[])null, (Type[])null);
			MethodInfo methodInfo2 = AccessTools.Method(typeof(PlayerControllerB), "KillPlayer", (Type[])null, (Type[])null);
			for (int i = 0; i < list.Count - 40; i++)
			{
				if (CodeInstructionExtensions.IsLdarg(list[i], (int?)0) && CodeInstructionExtensions.Calls(list[i + 3], methodInfo) && CodeInstructionExtensions.Calls(list[i + 40], methodInfo2))
				{
					num = i;
					break;
				}
			}
			if (num > -1)
			{
				for (int j = num; j < num + 4; j++)
				{
					list[j].opcode = OpCodes.Nop;
					list[j].operand = null;
				}
				list[num].opcode = OpCodes.Ldarg_0;
				list[num].operand = null;
				list[num + 1].opcode = OpCodes.Call;
				list[num + 1].operand = DamagePlayersInLOSMethod;
				num = -1;
			}
			else
			{
				Plugin.LogError("LethalBot.Patches.MapHazardsPatches.TurretPatch.Update_Transpiler use other method for shooting player/bot in TurretMode.Firing");
			}
			for (int k = 0; k < list.Count - 40; k++)
			{
				if (CodeInstructionExtensions.IsLdarg(list[k], (int?)0) && CodeInstructionExtensions.Calls(list[k + 3], methodInfo) && CodeInstructionExtensions.Calls(list[k + 40], methodInfo2))
				{
					num = k;
					break;
				}
			}
			if (num > -1)
			{
				for (int l = num; l < num + 4; l++)
				{
					list[l].opcode = OpCodes.Nop;
					list[l].operand = null;
				}
				list[num].opcode = OpCodes.Ldarg_0;
				list[num].operand = null;
				list[num + 1].opcode = OpCodes.Call;
				list[num + 1].operand = DamagePlayersInLOSMethod;
				num = -1;
			}
			else
			{
				Plugin.LogError("LethalBot.Patches.MapHazardsPatches.TurretPatch.Update_Transpiler use other method for shooting player/bot in TurretMode.berzerk");
			}
			return list.AsEnumerable();
		}

		private static PlayerControllerB? DamagePlayersInLOS(Turret turret)
		{
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			PlayerControllerB val = turret.CheckForPlayersInLineOfSight(3f, false);
			if ((Object)(object)val == (Object)null)
			{
				return null;
			}
			LethalBotAI lethalBotAIIfLocalIsOwner = LethalBotManager.Instance.GetLethalBotAIIfLocalIsOwner(val);
			if ((Object)(object)lethalBotAIIfLocalIsOwner == (Object)null)
			{
				return val;
			}
			if (val.health > 50)
			{
				val.DamagePlayer(50, true, true, (CauseOfDeath)7, 0, false, default(Vector3));
			}
			else
			{
				Plugin.LogDebug($"SyncKillLethalBot from turret for LOCAL client #{((NetworkBehaviour)lethalBotAIIfLocalIsOwner).NetworkManager.LocalClientId}, lethalBot object: Bot #{lethalBotAIIfLocalIsOwner.BotId}");
				val.KillPlayer(turret.aimPoint.forward * 40f, true, (CauseOfDeath)7, 0, default(Vector3), false);
			}
			return null;
		}
	}
}
namespace LethalBots.Patches.GameEnginePatches
{
	[HarmonyPatch(typeof(AudioMixer))]
	public class AudioMixerPatch
	{
		[HarmonyPatch("SetFloat")]
		[HarmonyPrefix]
		public static bool SetFloat_Prefix(string name, float value)
		{
			if (!name.StartsWith("PlayerPitch"))
			{
				return true;
			}
			string s = name.Replace("PlayerVolume", "").Replace("PlayerPitch", "");
			int num = int.Parse(s);
			PlayerControllerB val = StartOfRound.Instance.allPlayerScripts[num];
			if ((Object)(object)val == (Object)null || !LethalBotManager.Instance.IsPlayerLethalBot(val))
			{
				return true;
			}
			AudioSource currentVoiceChatAudioSource = val.currentVoiceChatAudioSource;
			if ((Object)(object)currentVoiceChatAudioSource != (Object)null)
			{
				if (name.StartsWith("PlayerVolume"))
				{
					currentVoiceChatAudioSource.volume = value / 16f;
				}
				else if (name.StartsWith("PlayerPitch"))
				{
					currentVoiceChatAudioSource.pitch = value;
				}
			}
			return false;
		}
	}
	[HarmonyPatch(typeof(AudioReverbTrigger))]
	public class AudioReverbTriggerPatch
	{
		[HarmonyPatch("ChangeAudioReverbForPlayer")]
		[HarmonyPrefix]
		public static bool ChangeAudioReverbForPlayer_Prefix(AudioReverbTrigger __instance, PlayerControllerB pScript, bool __runOriginal)
		{
			if (!__runOriginal)
			{
				return true;
			}
			if ((Object)(object)GameNetworkManager.Instance.localPlayerController == (Object)null || (Object)(object)pScript.currentAudioTrigger == (Object)(object)__instance || !pScript.isPlayerControlled)
			{
				return true;
			}
			if (__instance.elevatorTriggerForProps && LethalBotManager.Instance.IsPlayerLethalBot(pScript) && LethalBotManager.IsTheShipLanding() && (pScript.isInElevator || pScript.isInHangarShipRoom))
			{
				return false;
			}
			Plugin.LogDebug("AudioReverbTrigger::ChangeAudioReverbForPlayer called by Player " + pScript.playerUsername + "!");
			return true;
		}
	}
	[HarmonyPatch(typeof(Debug))]
	public class DebugPatch
	{
		[HarmonyPatch("LogError", new Type[] { typeof(object) })]
		[HarmonyPrefix]
		public static bool LogError_Prefix()
		{
			Plugin.LogDebug(Environment.StackTrace);
			return true;
		}
	}
	[HarmonyPatch(typeof(GameNetworkManager))]
	public class GameNetworkManagerPatch
	{
		[HarmonyPatch("SaveGame")]
		[HarmonyPostfix]
		public static void SaveGame_Postfix(GameNetworkManager __instance)
		{
			SaveManager.Instance.SavePluginInfos();
		}

		[HarmonyPatch("Singleton_OnClientDisconnectCallback")]
		[HarmonyPrefix]
		private static void Singleton_OnClientDisconnectCallback_Prefix(GameNetworkManager __instance, ulong clientId)
		{
			if ((Object)(object)NetworkManager.Singleton == (Object)null || clientId == NetworkManager.Singleton.LocalClientId || !NetworkManager.Singleton.IsServer)
			{
				return;
			}
			LethalBotManager.Instance.sendPlayerCountUpdate.Value = true;
			int num = -1;
			if (StartOfRound.Instance.ClientPlayerList.TryGetValue(clientId, out var value))
			{
				num = (int)StartOfRound.Instance.allPlayerScripts[value].playerClientId;
			}
			Terminal terminal = TerminalManager.Instance.GetTerminal();
			InteractTrigger val = PatchesUtil.terminalTriggerField.Invoke(terminal);
			LethalBotAI[] lethalBotAIs = LethalBotManager.Instance.GetLethalBotAIs();
			foreach (LethalBotAI lethalBotAI in lethalBotAIs)
			{
				if ((Object)(object)lethalBotAI != (Object)null && (((NetworkBehaviour)lethalBotAI).OwnerClientId == clientId || ((EnemyAI)lethalBotAI).currentOwnershipOnThisClient == num))
				{
					((EnemyAI)lethalBotAI).ChangeOwnershipOfEnemy(0uL);
					if ((Object)(object)lethalBotAI.NpcController.Npc.currentTriggerInAnimationWith == (Object)(object)val)
					{
						lethalBotAI.LeaveTerminal(syncTerminalInUse: true, forceEndUse: true);
					}
				}
			}
		}

		[HarmonyPatch("ConnectionApproval")]
		[HarmonyPrefix]
		private static bool ConnectionApproval_Prefix(GameNetworkManager __instance, ref ConnectionApprovalRequest request, ref ConnectionApprovalResponse response)
		{
			if (request.ClientNetworkId == NetworkManager.Singleton.LocalClientId)
			{
				return true;
			}
			if (__instance.disallowConnection)
			{
				return true;
			}
			int num = LethalBotManager.Instance?.GetNextAvailablePlayerObject() ?? 0;
			if (num < 0)
			{
				response.Reason = "Lobby is full!";
				response.CreatePlayerObject = false;
				response.Approved = false;
				response.Pending = false;
				return false;
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(HUDManager))]
	[HarmonyAfter(new string[] { "Swaggies.BetterEXP" })]
	public class HUDManagerPatch
	{
		[HarmonyPatch("DisplayGlobalNotification")]
		[HarmonyReversePatch(/*Could not decode attribute arguments.*/)]
		[HarmonyPriority(0)]
		public static void DisplayGlobalNotification_ReversePatch(object instance, string displayText)
		{
			throw new NotImplementedException("Stub LethalBot.Patches.GameEnginePatches.HUDManagerPatch.DisplayGlobalNotification_ReversePatch");
		}

		[HarmonyPatch("AddPlayerChatMessageServerRpc")]
		[HarmonyReversePatch(/*Could not decode attribute arguments.*/)]
		[HarmonyPriority(0)]
		public static void AddPlayerChatMessageServerRpc_ReversePatch(object instance, string chatMessage, int playerId)
		{
			throw new NotImplementedException("Stub LethalBot.Patches.GameEnginePatches.HUDManagerPatch.AddPlayerChatMessageServerRpc_ReversePatch");
		}

		[HarmonyPatch("UpdateSpectateBoxSpeakerIcons")]
		[HarmonyPostfix]
		public static void UpdateSpectateBoxSpeakerIcons_Postfix(HUDManager __instance, ref Dictionary<Animator, PlayerControllerB> ___spectatingPlayerBoxes)
		{
			for (int i = 0; i < ___spectatingPlayerBoxes.Count; i++)
			{
				KeyValuePair<Animator, PlayerControllerB> keyValuePair = ___spectatingPlayerBoxes.ElementAt(i);
				PlayerControllerB value = keyValuePair.Value;
				if (!value.isPlayerControlled && !value.isPlayerDead)
				{
					continue;
				}
				LethalBotAI lethalBotAI = LethalBotManager.Instance.GetLethalBotAI(value);
				if ((Object)(object)lethalBotAI == (Object)null)
				{
					continue;
				}
				LethalBotVoice lethalBotVoice = lethalBotAI.LethalBotIdentity?.Voice;
				if (lethalBotVoice != null)
				{
					bool flag = false;
					if (lethalBotVoice.IsTalking() && lethalBotVoice.GetVoiceAmplitude() > 0.005f)
					{
						flag = true;
					}
					keyValuePair.Key.SetBool("speaking", flag);
				}
			}
		}

		[HarmonyPatch("UseSignalTranslatorClientRpc")]
		[HarmonyPostfix]
		public static void UseSignalTranslatorClientRpc_Postfix(HUDManager __instance, string signalMessage)
		{
			LethalBotManager.Instance.LethalBotsRespondToSignalTranslator(signalMessage);
		}

		[HarmonyPatch("AddPlayerChatMessageClientRpc")]
		[HarmonyPostfix]
		public static void AddPlayerChatMessageClientRpc_Postfix(HUDManager __instance, string chatMessage, int playerId)
		{
			LethalBotManager.Instance.LethalBotsRespondToChatMessage(chatMessage, playerId);
		}

		[HarmonyPatch("FillImageWithSteamProfile")]
		[HarmonyPrefix]
		public static bool FillImageWithSteamProfile_Prefix(HUDManager __instance, ref RawImage image, ref SteamId steamId, ref bool large)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			if (!((SteamId)(ref steamId)).IsValid)
			{
				Plugin.LogWarning($"FillImageWithSteamProfile: Invaild steam id {steamId} or steam id is a bot. Aboring FillImageWithSteamProfile to prevent errors.");
				return false;
			}
			return true;
		}

		[HarmonyPatch("ChangeControlTipMultiple")]
		[HarmonyPostfix]
		public static void ChangeControlTipMultiple_Postfix(HUDManager __instance)
		{
			InputManager.Instance.AddLethalBotsControlTip(__instance);
		}

		[HarmonyPatch("ClearControlTips")]
		[HarmonyPostfix]
		public static void ClearControlTips_Postfix(HUDManager __instance)
		{
			InputManager.Instance.AddLethalBotsControlTip(__instance);
		}

		[HarmonyPatch("ChangeControlTip")]
		[HarmonyPostfix]
		public static void ChangeControlTip_Postfix(HUDManager __instance)
		{
			InputManager.Instance.AddLethalBotsControlTip(__instance);
		}
	}
	[HarmonyPatch(typeof(NetworkObject))]
	public class NetworkObjectPatch
	{
		[HarmonyPatch("ChangeOwnership")]
		[HarmonyPrefix]
		private static bool ChangeOwnership_PreFix(ref ulong newOwnerClientId)
		{
			Plugin.LogDebug($"Try network object ChangeOwnership newOwnerClientId : {(int)newOwnerClientId}");
			if (newOwnerClientId > 200000)
			{
				LethalBotAI lethalBotAI = LethalBotManager.Instance.GetLethalBotAI((int)(newOwnerClientId - 200000));
				if ((Object)(object)lethalBotAI != (Object)null)
				{
					Plugin.LogDebug($"network ChangeOwnership not on lethalBot but on lethalBot owner : {((NetworkBehaviour)lethalBotAI).OwnerClientId}");
					newOwnerClientId = ((NetworkBehaviour)lethalBotAI).OwnerClientId;
				}
			}
			return true;
		}

		[HarmonyPatch("OnTransformParentChanged")]
		[HarmonyPrefix]
		private static bool OnTransformParentChanged_PreFix(NetworkObject __instance, Transform ___m_CachedParent)
		{
			return true;
		}
	}
	[HarmonyPatch(typeof(NetworkSceneManager))]
	[HarmonyAfter(new string[] { "me.swipez.melonloader.morecompany" })]
	[HarmonyBefore(new string[] { "Szumi57.LethalInterns" })]
	public class NetworkSceneManagerPatch
	{
		[HarmonyPatch("PopulateScenePlacedObjects")]
		[HarmonyPostfix]
		public static void PopulateScenePlacedObjects_Postfix()
		{
			if (Plugin.IsModMoreCompanyLoaded)
			{
				UpdateIrlPlayerAfterMoreCompany();
			}
			LethalBotManager.Instance?.ManagePoolOfBots();
		}

		private static void UpdateIrlPlayerAfterMoreCompany()
		{
			Plugin.PluginIrlPlayersCount = MainClass.newPlayerCount;
			Plugin.LogDebug($"PluginIrlPlayersCount after morecompany = {Plugin.PluginIrlPlayersCount}");
		}
	}
	[HarmonyPatch(typeof(NfgoPlayer))]
	public class NfgoPlayerPatch
	{
		[HarmonyPatch("VoiceChatTrackingStart")]
		[HarmonyPrefix]
		public static bool VoiceChatTrackingStart_Prefix(NfgoPlayer __instance)
		{
			PlayerControllerB component = ((Component)__instance).gameObject.GetComponent<PlayerControllerB>();
			if (LethalBotManager.Instance.IsPlayerLethalBot(component))
			{
				Plugin.LogWarning("[NfgoPlayerPatch] VoiceChatTrackingStart was called on a Bot. Aboring VoiceChatTrackingStart to prevent errors.");
				return false;
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(RoundManager))]
	public class RoundManagerPatch
	{
		[CompilerGenerated]
		private sealed class <UpdateNavmeshDelayed>d__2 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public List<NavMeshSurface> fullBakeSurfaces;

			private AdjacentRoomCullingModified <roomCullingModified>5__2;

			private bool <wasEnabed>5__3;

			private List<NavMeshSurface>.Enumerator <>7__wrap3;

			private NavMeshSurface <navMeshSurface>5__5;

			private AsyncOperation <asyncOperation>5__6;

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

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

			[DebuggerHidden]
			public <UpdateNavmeshDelayed>d__2(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || (uint)(num - 1) <= 2u)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<roomCullingModified>5__2 = null;
				<>7__wrap3 = default(List<NavMeshSurface>.Enumerator);
				<navMeshSurface>5__5 = null;
				<asyncOperation>5__6 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0109: Unknown result type (might be due to invalid IL or missing references)
				//IL_0113: Expected O, but got Unknown
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<roomCullingModified>5__2 = StartOfRound.Instance.occlusionCuller;
						<wasEnabed>5__3 = ((Behaviour)<roomCullingModified>5__2).enabled;
						<>7__wrap3 = fullBakeSurfaces.GetEnumerator();
						<>1__state = -3;
						goto IL_01bb;
					case 1:
						<>1__state = -3;
						<>2__current = (object)new WaitForEndOfFrame();
						<>1__state = 2;
						return true;
					case 2:
						<>1__state = -3;
						<asyncOperation>5__6 = <navMeshSurface>5__5.UpdateNavMesh(<navMeshSurface>5__5.navMeshData);
						goto IL_0164;
					case 3:
						{
							<>1__state = -3;
							goto IL_0164;
						}
						IL_0164:
						if (<asyncOperation>5__6 != null && !<asyncOperation>5__6.isDone)
						{
							<>2__current = null;
							<>1__state = 3;
							return true;
						}
						Plugin.LogDebug("UpdateNavMesh finished, refreshing surface data.");
						<navMeshSurface>5__5.RemoveData();
						Plugin.LogDebug("Removed existing data.");
						<navMeshSurface>5__5.AddData();
						Plugin.LogDebug("Added updated data.");
						<asyncOperation>5__6 = null;
						goto IL_01b4;
						IL_01b4:
						<navMeshSurface>5__5 = null;
						goto IL_01bb;
						IL_01bb:
						if (<>7__wrap3.MoveNext())
						{
							<navMeshSurface>5__5 = <>7__wrap3.Current;
							if ((Object)(object)<navMeshSurface>5__5 != (Object)null)
							{
								Plugin.LogDebug($"Updating NavMesh for surface {((Object)((Component)<navMeshSurface>5__5).gameObject).name} with {((Component)<navMeshSurface>5__5).GetComponentsInChildren<NavMeshModifierVolume>().Length} modifiers.");
								if ((Object)(object)<roomCullingModified>5__2 != (Object)null && ((Behaviour)<roomCullingModified>5__2).enabled)
								{
									<wasEnabed>5__3 = true;
									((Behaviour)<roomCullingModified>5__2).enabled = false;
								}
								<>2__current = null;
								<>1__state = 1;
								return true;
							}
							goto IL_01b4;
						}
						<>m__Finally1();
						<>7__wrap3 = default(List<NavMeshSurface>.Enumerator);
						if (<roomCullingModified>5__2 == null)
						{
							<roomCullingModified>5__2 = StartOfRound.Instance.occlusionCuller;
						}
						if ((Object)(object)<roomCullingModified>5__2 != (Object)null && ((Behaviour)<roomCullingModified>5__2).enabled != <wasEnabed>5__3)
						{
							((Behaviour)<roomCullingModified>5__2).enabled = <wasEnabed>5__3;
						}
						Plugin.LogDebug("Updated all interior NavMeshes.");
						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;
				((IDisposable)<>7__wrap3).Dispose();
			}

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

		[HarmonyPatch("SpawnOutsideHazards")]
		[HarmonyPostfix]
		private static void SpawnOutsideHazards_Postfix(RoundManager __instance)
		{
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Expected O, but got Unknown
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_0131: Unknown result type (might be due to invalid IL or missing references)
			//IL_0136: Unknown result type (might be due to invalid IL or missing references)
			//IL_0137: Unknown result type (might be due to invalid IL or missing references)
			//IL_0148: Unknown result type (might be due to invalid IL or missing references)
			//IL_0154: Unknown result type (might be due to invalid IL or missing references)
			QuicksandTrigger[] source = Object.FindObjectsOfType<QuicksandTrigger>(true);
			source = source.Where((QuicksandTrigger quicksand) => (Object)(object)quicksand != (Object)null && !quicksand.isWater).ToArray();
			if (source.Length == 0)
			{
				return;
			}
			Plugin.LogInfo("Adding NavMeshModifierVolume to the quicksand objects to override its path cost for bots!");
			bool flag = false;
			Vector3 val = default(Vector3);
			((Vector3)(ref val))..ctor(0.8f, 0.2f, 0.8f);
			QuicksandTrigger[] array = source;
			foreach (QuicksandTrigger val2 in array)
			{
				if ((Object)(object)val2 == (Object)null || val2.isWater)
				{
					continue;
				}
				BoxCollider[] componentsInChildren = ((Component)val2).gameObject.GetComponentsInChildren<BoxCollider>();
				for (int j = 0; j < componentsInChildren.Length; j++)
				{
					BoxCollider val3 = componentsInChildren[j];
					if ((Object)(object)val3 != (Object)null)
					{
						flag = true;
						GameObject val4 = new GameObject($"NavMeshModifier{j}");
						val4.transform.SetParent(((Component)val3).transform, true);
						val4.transform.localPosition = Vector3.zero;
						val4.transform.localRotation = Quaternion.identity;
						val4.layer = LayerMask.NameToLayer("NavigationSurface");
						NavMeshModifierVolume val5 = val4.AddComponent<NavMeshModifierVolume>();
						val5.area = 27;
						val5.center = val3.center;
						val5.size = val3.size + val;
						Plugin.LogInfo($"Added NavMeshModifierVolume to quicksand with center {val5.center} and size {val5.size}.");
					}
				}
			}
			if (flag)
			{
				GameObject val6 = GameObject.FindGameObjectWithTag("OutsideLevelNavMesh");
				if ((Object)(object)val6 != (Object)null)
				{
					NavMeshSurface component = val6.GetComponent<NavMeshSurface>();
					Plugin.LogDebug($"Updating NavMesh for surface {((Object)((Component)component).gameObject).name} with {((Component)component).GetComponentsInChildren<NavMeshModifierVolume>().Length} modifiers.");
					component.UpdateNavMesh(component.navMeshData);
					Plugin.LogDebug("UpdateNavMesh finished, refreshing surface data.");
					component.RemoveData();
					Plugin.LogDebug("Removed existing data.");
					component.AddData();
					Plugin.LogDebug("Added updated data.");
				}
			}
		}

		[HarmonyPatch("SpawnMapObjects")]
		[HarmonyPostfix]
		private static void SpawnMapObjects_Postfix(RoundManager __instance, List<NavMeshSurface> ___fullBakeSurfaces)
		{
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Expected O, but got Unknown
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Expected O, but got Unknown
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			//IL_0138: Unknown result type (might be due to invalid IL or missing references)
			//IL_0146: Unknown result type (might be due to invalid IL or missing references)
			//IL_014b: Unknown result type (might be due to invalid IL or missing references)
			//IL_014c: Unknown result type (might be due to invalid IL or missing references)
			//IL_015d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0169: Unknown result type (might be due to invalid IL or missing references)
			if (__instance.currentLevel.indoorMapHazards.Length == 0)
			{
				return;
			}
			bool flag = false;
			Vector3 val = default(Vector3);
			((Vector3)(ref val))..ctor(0.8f, 0.2f, 0.8f);
			Landmine[] array = Object.FindObjectsOfType<Landmine>(true);
			if (array.Length == 0)
			{
				return;
			}
			Plugin.LogInfo("Adding NavMeshModifierVolume to the landmine objects to override its path cost for bots!");
			Dungeon currentDungeon = __instance.dungeonGenerator.Generator.CurrentDungeon;
			GameObject val2 = new GameObject("LandmineNavModifiers");
			val2.transform.SetParent(((Component)currentDungeon).gameObject.transform, false);
			Transform transform = val2.transform;
			Landmine[] array2 = array;
			foreach (Landmine val3 in array2)
			{
				if (!((Object)(object)val3 != (Object)null))
				{
					continue;
				}
				BoxCollider[] componentsInChildren = ((Component)val3).gameObject.GetComponentsInChildren<BoxCollider>();
				for (int j = 0; j < componentsInChildren.Length; j++)
				{
					BoxCollider val4 = componentsInChildren[j];
					if ((Object)(object)val4 != (Object)null)
					{
						flag = true;
						GameObject val5 = new GameObject($"LandmineNavMeshModifier{j}");
						val5.transform.SetParent(transform, true);
						val5.transform.SetPositionAndRotation(((Component)val4).transform.position, ((Component)val4).transform.rotation);
						val5.layer = LayerMask.NameToLayer("NavigationSurface");
						NavMeshModifierVolume val6 = val5.AddComponent<NavMeshModifierVolume>();
						val6.area = 26;
						val6.center = val4.center;
						val6.size = val4.size + val;
						Plugin.LogDebug($"Added NavMeshModifierVolume to landmine with center {val6.center} and size {val6.size}.");
					}
				}
			}
			if (flag)
			{
				Plugin.LogInfo("Updating NavMesh for all full bake surfaces in the dungeon to apply the new modifiers!");
				((MonoBehaviour)__instance).StartCoroutine(UpdateNavmeshDelayed(___fullBakeSurfaces));
			}
		}

		[IteratorStateMachine(typeof(<UpdateNavmeshDelayed>d__2))]
		private static IEnumerator UpdateNavmeshDelayed(List<NavMeshSurface> fullBakeSurfaces)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <UpdateNavmeshDelayed>d__2(0)
			{
				fullBakeSurfaces = fullBakeSurfaces
			};
		}

		[HarmonyPatch("GetLayermaskForEnemySizeLimit")]
		[HarmonyPostfix]
		private static void GetLayermaskForEnemySizeLimit_Postfix(RoundManager __instance, bool supplyExistingMask, ref int __result)
		{
			if (supplyExistingMask)
			{
				int num = 469762048;
				__result |= num;
			}
		}

		[HarmonyPatch("LoadNewLevel")]
		[HarmonyPrefix]
		public static bool LoadNewLevel_Postfix(RoundManager __instance)
		{
			return true;
		}

		[HarmonyPatch("GenerateNewFloor")]
		[HarmonyPrefix]
		private static void GenerateNewFloor_Postfix(RoundManager __instance)
		{
		}

		[HarmonyPatch("BakeDunGenNavMesh")]
		[HarmonyPrefix]
		private static void BakeDunGenNavMesh_PreFix()
		{
			LethalBotManager.Instance?.DisableShipNavMesh("Landing on a moon.");
		}

		[HarmonyPatch("FinishGeneratingLevel")]
		[HarmonyPostfix]
		private static void FinishGeneratingLevel_PostFix(RoundManager __instance)
		{
			if (((NetworkBehaviour)__instance).IsServer || ((NetworkBehaviour)__instance).IsHost)
			{
				LethalBotManager.Instance.MarkBotsAsGeneratedFloorDelayed();
			}
			Dungeon dungeon = Object.FindObjectOfType<Dungeon>();
			LethalBotAI[] lethalBotAIs = LethalBotManager.Instance.GetLethalBotAIs();
			foreach (LethalBotAI lethalBotAI in lethalBotAIs)
			{
				PlayerControllerB val = lethalBotAI.NpcController?.Npc;
				if ((Object)(object)val != (Object)null && (val.isPlayerControlled || val.isPlayerDead))
				{
					DunGenTileTracker dunGenTileTracker = lethalBotAI.DunGenTileTracker;
					dunGenTileTracker.SetDungeon(dungeon);
					dunGenTileTracker.AdjacentTileDepth = __instance.dungeonFlowTypes[__instance.currentDungeonType].cullingTileDepth;
				}
			}
		}

		[HarmonyPatch("FinishGeneratingNewLevelClientRpc")]
		[HarmonyPostfix]
		private static void FinishGeneratingNewLevelClientRpc_PostFix()
		{
			string[] obj = new string[6]
			{
				$"[SpawnLethalBotsAtShip] Manager Instance: {LethalBotManager.Instance}, ",
				null,
				null,
				null,
				null,
				null
			};
			LethalBotManager instance = LethalBotManager.Instance;
			obj[1] = $"IsSpawned: {((instance != null) ? new bool?(((NetworkBehaviour)instance).IsSpawned) : null)}, ";
			LethalBotManager instance2 = LethalBotManager.Instance;
			obj[2] = $"NetworkObject: {((instance2 != null) ? ((NetworkBehaviour)instance2).NetworkObject : null)}, ";
			LethalBotManager instance3 = LethalBotManager.Instance;
			ulong? obj2;
			if (instance3 == null)
			{
				obj2 = null;
			}
			else
			{
				NetworkObject networkObject = ((NetworkBehaviour)instance3).NetworkObject;
				obj2 = ((networkObject != null) ? new ulong?(networkObject.NetworkObjectId) : null);
			}
			obj[3] = $"NetObjID: {obj2}, ";
			LethalBotManager instance4 = LethalBotManager.Instance;
			obj[4] = $"IsServer: {((instance4 != null) ? new bool?(((NetworkBehaviour)instance4).IsServer) : null)}, ";
			LethalBotManager instance5 = LethalBotManager.Instance;
			obj[5] = $"IsHost: {((instance5 != null) ? new bool?(((NetworkBehaviour)instance5).IsHost) : null)}";
			Plugin.LogDebug(string.Concat(obj));
			LethalBotManager.Instance?.DisableShipNavMesh("Landing on a moon.");
			LethalBotManager.Instance?.SpawnLethalBotsAtShip();
		}

		[HarmonyPatch("RefreshEnemiesList")]
		[HarmonyPostfix]
		private static void RefreshEnemiesList_PostFix(RoundManager __instance)
		{
			int count = __instance.SpawnedEnemies.Count;
			__instance.SpawnedEnemies.RemoveAll((EnemyAI enemy) => enemy is LethalBotAI);
			__instance.numberOfEnemiesInScene = __instance.SpawnedEnemies.Count;
			Plugin.LogDebug($"Removed LethalBotAI objects from RoundManager.SpawnedEnemies. Old {count} -> New {__instance.numberOfEnemiesInScene}");
		}

		[HarmonyPatch("UnloadSceneObjectsEarly")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> UnloadSceneObjectsEarly_Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator generator)
		{
			//IL_012e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0138: Expected O, but got Unknown
			//IL_013f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0149: Expected O, but got Unknown
			//IL_0150: Unknown result type (might be due to invalid IL or missing references)
			//IL_015a: Expected O, but got Unknown
			//IL_0162: Unknown result type (might be due to invalid IL or missing references)
			//IL_016c: Expected O, but got Unknown
			//IL_0179: Unknown result type (might be due to invalid IL or missing references)
			//IL_0183: Expected O, but got Unknown
			int num = -1;
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			MethodInfo methodInfo = AccessTools.Method(typeof(NetworkObject), "Despawn", (Type[])null, (Type[])null);
			FieldInfo fieldInfo = AccessTools.Field(typeof(EnemyAI), "thisNetworkObject");
			MethodInfo methodInfo2 = AccessTools.Method(typeof(RoundManagerPatch), "ShouldDespawn", (Type[])null, (Type[])null);
			for (int i = 0; i < list.Count - 5; i++)
			{
				if (list[i].opcode == OpCodes.Ldloc_0 && list[i + 1].opcode == OpCodes.Ldloc_3 && list[i + 2].opcode == OpCodes.Ldelem_Ref && CodeInstructionExtensions.LoadsField(list[i + 3], fieldInfo, false) && list[i + 4].opcode == OpCodes.Ldc_I4_1 && CodeInstructionExtensions.Calls(list[i + 5], methodInfo))
				{
					num = i;
					break;
				}
			}
			if (num > -1)
			{
				Label label = generator.DefineLabel();
				list[num + 6].labels.Add(label);
				List<CodeInstruction> collection = new List<CodeInstruction>
				{
					new CodeInstruction(OpCodes.Ldloc_0, (object)null),
					new CodeInstruction(OpCodes.Ldloc_3, (object)null),
					new CodeInstruction(OpCodes.Ldelem_Ref, (object)null),
					new CodeInstruction(OpCodes.Call, (object)methodInfo2),
					new CodeInstruction(OpCodes.Brfalse, (object)label)
				};
				list.InsertRange(num, collection);
				num = -1;
			}
			else
			{
				Plugin.LogError("LethalBot.Patches.GameEnginePatches.UnloadSceneObjectsEarly_Transpiler could not add custom check to block deletion of EnemyAI objects for Lethal Bots!");
			}
			return list.AsEnumerable();
		}

		private static bool ShouldDespawn(EnemyAI enemyAI)
		{
			if (Plugin.Config.AllowBotsInOrbit.Value && enemyAI is LethalBotAI)
			{
				return false;
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(SoundManager))]
	public class SoundManagerPatch
	{
		[HarmonyPatch("Update")]
		[HarmonyPrefix]
		private static bool Update_PreFix(ref PlayerControllerB ___localPlayer)
		{
			___localPlayer = GameNetworkManager.Instance.localPlayerController;
			if ((Object)(object)___localPlayer == (Object)null || (Object)(object)NetworkManager.Singleton == (Object)null)
			{
				return false;
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(StartOfRound))]
	public class StartOfRoundPatch
	{
		[CompilerGenerated]
		private sealed class <LoadBlacklistedItemsCoroutine>d__3 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public StartOfRound instanceSOR;

			private int <failedToBlacklist>5__2;

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

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

			[DebuggerHidden]
			public <LoadBlacklistedItemsCoroutine>d__3(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0061: Unknown result type (might be due to invalid IL or missing references)
				//IL_006b: Expected O, but got Unknown
				//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f2: 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_00fb: Unknown result type (might be due to invalid IL or missing references)
				//IL_0111: Unknown result type (might be due to invalid IL or missing references)
				//IL_0116: Unknown result type (might be due to invalid IL or missing references)
				//IL_0282: Unknown result type (might be due to invalid IL or missing references)
				//IL_028c: Expected O, but got Unknown
				//IL_0232: Unknown result type (might be due to invalid IL or missing references)
				//IL_01ca: Unknown result type (might be due to invalid IL or missing references)
				//IL_01cf: Unknown result type (might be due to invalid IL or missing references)
				//IL_01d1: Unknown result type (might be due to invalid IL or missing references)
				//IL_01d6: Unknown result type (might be due to invalid IL or missing references)
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = null;
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<>2__current = (object)new WaitUntil((Func<bool>)(() => (Object)(object)LethalBotManager.Instance != (Object)null && ((NetworkBehaviour)LethalBotManager.Instance).IsSpawned));
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					<>2__current = null;
					<>1__state = 3;
					return true;
				case 3:
				{
					<>1__state = -1;
					LethalBotBlacklistedItem[] array = SaveManager.Instance?.Save?.BlacklistedItems;
					if (array == null || array.Length == 0)
					{
						return false;
					}
					<failedToBlacklist>5__2 = 0;
					HashSet<GrabbableObject> hashSet = new HashSet<GrabbableObject>();
					GrabbableObject[] array2 = Object.FindObjectsOfType<GrabbableObject>();
					LethalBotBlacklistedItem[] array3 = array;
					foreach (LethalBotBlacklistedItem lethalBotBlacklistedItem in array3)
					{
						Vector3 val = lethalBotBlacklistedItem.SavedPosition;
						Bounds bounds = instanceSOR.shipBounds.bounds;
						if (!((Bounds)(ref bounds)).Contains(val))
						{
							val = instanceSOR.playerSpawnPositions[1].position;
							val.x += Random.Range(-0.7f, 0.7f);
							val.z += Random.Range(-2f, 2f);
							val.y += 0.5f;
						}
						GrabbableObject val2 = null;
						float num = float.MaxValue;
						GrabbableObject[] array4 = array2;
						foreach (GrabbableObject val3 in array4)
						{
							if ((Object)(object)val3 == (Object)null || hashSet.Contains(val3))
							{
								continue;
							}
							Item itemProperties = val3.itemProperties;
							if (!(itemProperties.itemName != lethalBotBlacklistedItem.itemName) && (!lethalBotBlacklistedItem.hasScrapValue || val3.scrapValue == lethalBotBlacklistedItem.scrapValue))
							{
								Vector3 val4 = ((Component)val3).transform.position - val;
								float sqrMagnitude = ((Vector3)(ref val4)).sqrMagnitude;
								if (sqrMagnitude < num)
								{
									val2 = val3;
									num = sqrMagnitude;
								}
							}
						}
						if ((Object)(object)val2 != (Object)null)
						{
							Plugin.LogInfo($"Found grabbable object {val2}, for blacklisted item {lethalBotBlacklistedItem}");
							hashSet.Add(val2);
							LethalBotManager.Instance.RegisterItemAsBlacklisted(NetworkObjectReference.op_Implicit(((NetworkBehaviour)val2).NetworkObject));
						}
						else
						{
							Plugin.LogWarning($"Failed to find grabbable object for blacklisted item {lethalBotBlacklistedItem}");
							<failedToBlacklist>5__2++;
						}
					}
					if (<failedToBlacklist>5__2 > 0)
					{
						<>2__current = (object)new WaitForSeconds(5.5f);
						<>1__state = 4;
						return true;
					}
					break;
				}
				case 4:
					<>1__state = -1;
					HUDManager.Instance.DisplayTip("WARNING!", $"Lethal Bots failed to find {<failedToBlacklist>5__2} items in the sell blacklist. You should manually readd all items you don't want the bots to sell!!!!", true, false, "LC_Tip1");
					break;
				}
				loadBlacklistedItemsCoroutine = null;
				return false;
			}

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

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

		private static Coroutine? loadBlacklistedItemsCoroutine;

		[HarmonyPatch("Awake")]
		[HarmonyPrefix]
		private static void Awake_Prefix(StartOfRound __instance)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Expected O, but got Unknown
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Expected O, but got Unknown
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Expected O, but got Unknown
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Expected O, but got Unknown
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Expected O, but got Unknown
			Plugin.LogDebug("Initialize managers...");
			GameObject val = new GameObject("InputManager");
			val.AddComponent<InputManager>();
			val = new GameObject("AudioManager");
			val.AddComponent<AudioManager>();
			val = new GameObject("IdentityManager");
			val.AddComponent<IdentityManager>();
			val = new GameObject("LoadoutManager");
			val.AddComponent<LoadoutManager>();
			val = new GameObject("RestockManager");
			val.AddComponent<RestockManager>();
			val = Object.Instantiate<GameObject>(PluginManager.Instance.TerminalManagerPrefab);
			if (((NetworkBehaviour)__instance).NetworkManager.IsHost || ((NetworkBehaviour)__instance).NetworkManager.IsServer)
			{
				val.GetComponent<NetworkObject>().Spawn(false);
			}
			val = Object.Instantiate<GameObject>(PluginManager.Instance.SaveManagerPrefab);
			if (((NetworkBehaviour)__instance).NetworkManager.IsHost || ((NetworkBehaviour)__instance).NetworkManager.IsServer)
			{
				val.GetComponent<NetworkObject>().Spawn(false);
			}
			val = Object.Instantiate<GameObject>(PluginManager.Instance.GroupManagerPrefab);
			if (((NetworkBehaviour)__instance).NetworkManager.IsHost || ((NetworkBehaviour)__instance).NetworkManager.IsServer)
			{
				val.GetComponent<NetworkObject>().Spawn(false);
			}
			val = Object.Instantiate<GameObject>(PluginManager.Instance.LethalBotManagerPrefab);
			if (((NetworkBehaviour)__instance).NetworkManager.IsHost || ((NetworkBehaviour)__instance).NetworkManager.IsServer)
			{
				val.GetComponent<NetworkObject>().Spawn(false);
			}
			Plugin.LogDebug("... Managers started");
		}

		[HarmonyPatch("LoadShipGrabbableItems")]
		[HarmonyPrefix]
		private static void LoadShipGrabbableItems_PreFix(StartOfRound __instance)
		{
			if (((NetworkBehaviour)__instance).NetworkManager.IsHost || ((NetworkBehaviour)__instance).NetworkManager.IsServer)
			{
				if (loadBlacklistedItemsCoroutine != null)
				{
					((MonoBehaviour)__instance).StopCoroutine(loadBlacklistedItemsCoroutine);
				}
				loadBlacklistedItemsCoroutine = ((MonoBehaviour)__instance).StartCoroutine(LoadBlacklistedItemsCoroutine(__instance));
			}
		}

		[IteratorStateMachine(typeof(<LoadBlacklistedItemsCoroutine>d__3))]
		private static IEnumerator LoadBlacklistedItemsCoroutine(StartOfRound instanceSOR)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <LoadBlacklistedItemsCoroutine>d__3(0)
			{
				instanceSOR = instanceSOR
			};
		}

		[HarmonyPatch("ShipHasLeft")]
		[HarmonyPrefix]
		private static void ShipHasLeft_PreFix()
		{
			LethalBotManager.Instance.SyncEndOfRoundLethalBots(preRevive: true);
		}

		[HarmonyPatch("ReviveDeadPlayers")]
		[HarmonyPostfix]
		private static void ReviveDeadPlayers_PostFix()
		{
			LethalBotManager.Instance.SyncEndOfRoundLethalBots();
		}

		[HarmonyPatch("SetShipReadyToLand")]
		[HarmonyPostfix]
		private static void SetShipReadyToLand_Postfix()
		{
			Plugin.LogDebug("Creating and Enabling ship NavMeshSurface object");
			LethalBotManager.Instance.EnsureShipNavMeshBuilt();
			LethalBotManager.Instance.EnableShipNavMesh("Now in orbit!");
		}

		[HarmonyPatch("SyncAlreadyHeldObjectsClientRpc")]
		[HarmonyPostfix]
		private static void SyncAlreadyHeldObjectsClientRpc_PostFix(StartOfRound __instance)
		{
			if ((Object)(object)LethalBotManager.Instance == (Object)null)
			{
				return;
			}
			LethalBotAI[] lethalBotAIs = LethalBotManager.Instance.GetLethalBotAIs();
			foreach (LethalBotAI lethalBotAI in lethalBotAIs)
			{
				PlayerControllerB val = lethalBotAI?.NpcController?.Npc;
				if ((Object)(object)val != (Object)null && (Object)(object)val.currentlyHeldObjectServer != (Object)null && lethalBotAI != null)
				{
					lethalBotAI.HeldItem = val.currentlyHeldObjectServer;
				}
			}
		}

		[HarmonyPatch("SuckLocalPlayerOutOfShipDoor")]
		[HarmonyPostfix]
		private static void SuckLocalPlayerOutOfShipDoor_PostFix(StartOfRound __instance)
		{
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0164: Unknown result type (might be due to invalid IL or missing references)
			//IL_016a: Unknown result type (might be due to invalid IL or missing references)
			//IL_016f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0179: Unknown result type (might be due to invalid IL or missing references)
			//IL_017e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0159: Unknown result type (might be due to invalid IL or missing references)
			//IL_015e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: Unknown result type (might be due to invalid IL or missing references)
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			LethalBotAI[] lethalBotsAIOwnedByLocal = LethalBotManager.Instance.GetLethalBotsAIOwnedByLocal();
			foreach (LethalBotAI lethalBotAI in lethalBotsAIOwnedByLocal)
			{
				PlayerControllerB val = lethalBotAI.NpcController?.Npc;
				if (!((Object)(object)val != (Object)null))
				{
					continue;
				}
				val.fallValue = 0f;
				val.fallValueUncapped = 0f;
				Vector3 val2 = ((Component)val).transform.position - __instance.middleOfShipNode.position;
				if (((Vector3)(ref val2)).sqrMagnitude < 625f)
				{
					if (Physics.Linecast(((Component)val).transform.position, __instance.shipDoorNode.position, __instance.collidersAndRoomMask))
					{
						val.externalForces = Vector3.Normalize(__instance.middleOfShipNode.position - ((Component)val).transform.position) * 350f;
					}
					else
					{
						val.externalForces = Vector3.Normalize(__instance.middleOfSpaceNode.position - ((Component)val).transform.position) * (350f / Vector3.Distance(__instance.moveAwayFromShipNode.position, ((Component)val).transform.position)) * (__instance.suckingPower / 2.25f);
					}
					continue;
				}
				if (!lethalBotAI.choseRandomFlyDirForPlayer)
				{
					lethalBotAI.choseRandomFlyDirForPlayer = true;
					lethalBotAI.randomFlyDir = new Vector3(-1f, 0f, Random.Range(-0.7f, 0.7f));
				}
				val.externalForces = Vector3.Scale(Vector3.one, lethalBotAI.randomFlyDir) * 70f;
			}
		}

		[HarmonyPatch("EndOfGameClientRpc")]
		[HarmonyPostfix]
		private static void EndOfGameClientRpc_PostFix(StartOfRound __instance, int scrapCollectedOnServer, bool ___localPlayerWasMostProfitableThisRound)
		{
			if (__instance.currentLevel.planetHasTime)
			{
				LethalBotManager.Instance.UpdateLethalBotsXP(__instance, __instance.gameStats, ___localPlayerWasMostProfitableThisRound);
			}
		}

		[HarmonyPatch("DetectVoiceChatAmplitude")]
		[HarmonyPostfix]
		private static void DetectVoiceChatAmplitude_Postfix(StartOfRound __instance)
		{
			//IL_0146: Unknown result type (might be due to invalid IL or missing references)
			LethalBotAI[] lethalBotsAIOwnedByLocal = LethalBotManager.Instance.GetLethalBotsAIOwnedByLocal();
			foreach (LethalBotAI lethalBotAI in lethalBotsAIOwnedByLocal)
			{
				PlayerControllerB val = lethalBotAI.NpcController?.Npc;
				if (!((Object)(object)val != (Object)null))
				{
					continue;
				}
				LethalBotVoice lethalBotVoice = lethalBotAI.LethalBotIdentity?.Voice;
				if (lethalBotVoice == null)
				{
					continue;
				}
				float voiceAmplitude = lethalBotVoice.GetVoiceAmplitude();
				lethalBotVoice.averageCount++;
				if (lethalBotVoice.averageCount > __instance.movingAverageLength)
				{
					lethalBotVoice.averageVoiceAmplitude += (voiceAmplitude - lethalBotVoice.averageVoiceAmplitude) / (float)(__instance.movingAverageLength + 1);
				}
				else
				{
					lethalBotVoice.averageVoiceAmplitude += voiceAmplitude;
					if (lethalBotVoice.averageCount == __instance.movingAverageLength)
					{
						lethalBotVoice.averageVoiceAmplitude /= lethalBotVoice.averageCount;
					}
				}
				float num = voiceAmplitude / Mathf.Clamp(lethalBotVoice.averageVoiceAmplitude, 0.008f, 0.5f);
				if (lethalBotVoice.IsTalking() && lethalBotVoice.voiceChatNoiseCooldown <= 0f && num > 3f)
				{
					((UnityEvent<LethalBotVoice, float>)(object)LethalBotVoice.lethalBotTalkEvent).Invoke(lethalBotVoice, Mathf.Clamp(num / 14f, 0.4f, 1f));
					LethalBotManager.Instance.PlayAudibleNoiseForLethalBot(lethalBotVoice.BotID, ((Component)val).transform.position, Mathf.Clamp(3f * num, 3f, 36f), Mathf.Clamp(num / 7f, 0.6f, 0.9f), 5);
					lethalBotVoice.voiceChatNoiseCooldown = 0.2f;
				}
			}
		}

		[HarmonyPatch("SceneManager_OnLoadComplete1")]
		[HarmonyPostfix]
		private static void SceneManager_OnLoadComplete1_Postfix(StartOfRound __instance, ulong clientId, string sceneName)
		{
			__instance.ClientPlayerList.TryGetValue(clientId, out var value);
			if (value == 0)
			{
				LethalBotManager.Instance?.MarkBotsAsLoadedDelayed();
			}
		}

		[HarmonyPatch("SceneManager_OnUnloadComplete")]
		[HarmonyPostfix]
		private static void SceneManager_OnUnloadComplete_Postfix(StartOfRound __instance, ulong clientId, string sceneName)
		{
			if (sceneName == __instance.currentLevel.sceneName)
			{
				__instance.ClientPlayerList.TryGetValue(clientId, out var value);
				if (value == 0)
				{
					LethalBotManager.Instance?.MarkBotsAsLoadedDelayed();
				}
			}
		}

		[HarmonyPatch("GetPlayerSpawnPosition")]
		[HarmonyReversePatch(/*Could not decode attribute arguments.*/)]
		[HarmonyPriority(0)]
		public static Vector3 GetPlayerSpawnPosition_ReversePatch(object instance, int playerNum, bool simpleTeleport)
		{
			throw new NotImplementedException("Stub LethalBot.Patches.GameEnginePatches.StartOfRoundPatch.GetPlayerSpawnPosition_ReversePatch");
		}

		[HarmonyPatch("ReviveDeadPlayers")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> ReviveDeadPlayers_Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator generator)
		{
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Expected O, but got Unknown
			int num = -1;
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			MethodInfo methodInfo = AccessTools.PropertyGetter(typeof(NetworkBehaviour), "IsOwner");
			for (int i = 0; i < list.Count; i++)
			{
				if (CodeInstructionExtensions.Calls(list[i], methodInfo))
				{
					num = i;
					break;
				}
			}
			if (num > -1)
			{
				list[num] = CodeInstructionExtensions.WithLabels(new CodeInstruction(OpCodes.Call, (object)PatchesUtil.IsPlayerLocalMethod), (IEnumerable<Label>)list[num].labels);
				num = -1;
			}
			else
			{
				Plugin.LogError("LethalBot.Patches.GameEnginePatches.HUDManagerPatch.ReviveDeadPlayers could not stop redundant RemoveSpectatorUI calls.");
			}
			return list.AsEnumerable();
		}

		[HarmonyPatch("RefreshPlayerVoicePlaybackObjects")]
		[HarmonyTranspiler]
		public static IEnumerable<CodeInstruction> RefreshPlayerVoicePlaybackObjects_Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator generator)
		{
			int num = -1;
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			for (int i = 0; i < list.Count - 6; i++)
			{
				if (((object)list[i]).ToString().StartsWith("ldstr \"Refreshing voice playback objects. Number of voice objects found: {0}\"") && ((object)list[i + 6]).ToString().StartsWith("call static void UnityEngine.Debug::Log(object message)"))
				{
					num = i;
					break;
				}
			}
			if (num > -1)
			{
				PatchesUtil.InsertIsBypass(list, generator, num, 7);
				num = -1;
			}
			else
			{
				Plugin.LogError("LethalBot.Patches.GameEnginePatches.StartOfRoundPatch.RefreshPlayerVoicePlaybackObjects could not bypass debug log 1");
			}
			for (int j = 0; j < list.Count - 4; j++)
			{
				if (((object)list[j]).ToString().StartsWith("ldstr \"Skipping player #{0} as they are not controlled or dead\"") && ((object)list[j + 4]).ToString().StartsWith("call static void UnityEngine.Debug::Log(object message)"))
				{
					num = j;
					break;
				}
			}
			if (num > -1)
			{
				PatchesUtil.InsertIsBypass(list, generator, num, 6);
				num = -1;
			}
			else
			{
				Plugin.LogError("LethalBot.Patches.GameEnginePatches.StartOfRoundPatch.RefreshPlayerVoicePlaybackObjects could not bypass debug log 2");
			}
			for (int k = 0; k < list.Count - 6; k++)
			{
				if (((object)list[k]).ToString().StartsWith("ldstr \"Found a match for voice object") && ((object)list[k + 6]).ToString().StartsWith("call static void UnityEngine.Debug::Log(object message)"))
				{
					num = k;
					break;
				}
			}
			if (num > -1)
			{
				PatchesUtil.InsertIsBypass(list, generator, num, 7);
				num = -1;
			}
			else
			{
				Plugin.LogError("LethalBot.Patches.GameEnginePatches.StartOfRoundPatch.RefreshPlayerVoicePlaybackObjects could not bypass debug log 3");
			}
			for (int l = 0; l < list.Count - 30; l++)
			{
				if (((object)list[l]).ToString().StartsWith("ldstr \"player voice chat audiosource:") && ((object)list[l + 30]).ToString().StartsWith("call static void UnityEngine.Debug::Log(object message)"))
				{
					num = l;
					break;
				}
			}
			if (num > -1)
			{
				PatchesUtil.InsertIsBypass(list, generator, num, 31);
				num = -1;
			}
			else
			{
				Plugin.LogError("LethalBot.Patches.GameEnginePatches.StartOfRoundPatch.RefreshPlayerVoicePlaybackObjects could not bypass debug log 4");
			}
			return list.AsEnumerable();
		}

		[HarmonyPatch("UpdatePlayerVoiceEffects")]
		[HarmonyTranspiler]
		public static IEnumerable<CodeInstruction> UpdatePlayerVoiceEffects_Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator generator)
		{
			//IL_012a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0136: Expected O, but got Unknown
			//IL_0146: Unknown result type (might be due to invalid IL or missing references)
			//IL_0150: Expected O, but got Unknown
			//IL_0158: Unknown result type (might be due to invalid IL or missing references)
			//IL_0162: 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");
			MethodInfo methodInfo2 = AccessTools.Method(typeof(Object), "op_Equality", (Type[])null, (Type[])null);
			for (int i = 0; i < list.Count - 4; i++)
			{
				if (list[i].opcode == OpCodes.Ldloc_1 && CodeInstructionExtensions.Calls(list[i + 1], methodInfo) && CodeInstructionExtensions.LoadsField(list[i + 2], fieldInfo, false) && CodeInstructionExtensions.Calls(list[i + 3], methodInfo2) && (list[i + 4].opcode == OpCodes.Brtrue || list[i + 4].opcode == OpCodes.Brtrue_S))
				{
					num = i;
					break;
				}
			}
			if (num > -1)
			{
				List<Label> labels = list[num].labels;
				object operand = list[num + 4].operand;
				list.RemoveRange(num, 5);
				List<CodeInstruction> collection = new List<CodeInstruction>
				{
					CodeInstructionExtensions.WithLabels(new CodeInstruction(OpCodes.Ldloc_1, (object)null), (IEnumerable<Label>)labels),
					new CodeInstruction(OpCodes.Call, (object)PatchesUtil.IsPlayerLocalOrLethalBotMethod),
					new CodeInstruction(OpCodes.Brtrue, operand)
				};
				list.InsertRange(num, collection);
				num = -1;
			}
			else
			{
				Plugin.LogError("LethalBot.Patches.GameEnginePatches.StartOfRoundPatch.UpdatePlayerVoiceEffects_Transpiler could not change loop to only real players");
			}
			return list.AsEnumerable();
		}

		[HarmonyPatch("OnPlayerConnectedClientRpc")]
		[HarmonyPostfix]
		private static void OnPlayerConnectedClientRpc_PostFix(StartOfRound __instance, ulong clientId)
		{
			if (!((NetworkBehaviour)__instance).IsServer && !((NetworkBehaviour)__instance).IsHost && ((NetworkBehaviour)__instance).NetworkManager.LocalClientId == clientId)
			{
				LethalBotManager instance = LethalBotManager.Instance;
				instance.SyncLoadedJsonLoadoutsServerRpc(clientId);
				instance.SyncLoadedJsonIdentitiesServerRpc(clientId);
				instance.SyncLoadedJsonStockRequirementsServerRpc(clientId);
				instance.SyncLethalBotsToJoiningPlayerServerRpc(clientId);
				instance.RequestPlayerCountServerRpc(clientId);
				SaveManager.Instance.SyncCurrentValuesServerRpc(clientId);
			}
		}

		[HarmonyPatch("LateUpdate")]
		[HarmonyPostfix]
		private static void LateUpdate_PostFix(StartOfRound __instance)
		{
			LethalBotManager.Instance.UpdateOwnershipOfBotServer(Time.deltaTime);
		}

		[HarmonyPatch("OnDisable")]
		[HarmonyPostfix]
		private static void OnDisable_Postfix()
		{
			InputManager.Instance.RemoveEventHandlers();
		}

		[HarmonyPatch("KickPlayer")]
		[HarmonyPrefix]
		private static bool KickPlayer_Prefix(int playerObjToKick)
		{
			LethalBotAI lethalBotAI = LethalBotManager.Instance.GetLethalBotAI(playerObjToKick);
			if ((Object)(object)lethalBotAI != (Object)null)
			{
				LethalBotManager.Instance.OnLethalBotKicked(lethalBotAI);
				return false;
			}
			return true;
		}

		[HarmonyPatch("UpdatePlayerVoiceEffects")]
		[HarmonyPostfix]
		private static void UpdatePlayerVoiceEffects_PostFix()
		{
			LethalBotManager.Instance.UpdateAllLethalBotsVoiceEffects();
		}

		[HarmonyPatch("FirePlayersAfterDeadlineClientRpc")]
		[HarmonyPostfix]
		private static void FirePlayersAfterDeadlineClientRpc_PostFix()
		{
			if (Plugin.Config.ResetIdentitiesWhenFired.Value)
			{
				LethalBotManager.Instance.ResetIdentities();
			}
		}
	}
	[HarmonyPatch(typeof(TimeOfDay))]
	public class TimeOfDayPatch
	{
		[HarmonyPatch("SendHostInfoForShowingAdClientRpc")]
		[HarmonyPostfix]
		private static void SendHostInfoForShowingAdClientRpc_Postfix(TimeOfDay __instance)
		{
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			Plugin.LogDebug("Received client rpc Ad!");
			LethalBotAI[] lethalBotsAIOwnedByLocal = LethalBotManager.Instance.GetLethalBotsAIOwnedByLocal();
			LethalBotAI[] array = lethalBotsAIOwnedByLocal;
			foreach (LethalBotAI lethalBotAI in array)
			{
				if ((Object)(object)lethalBotAI == (Object)null)
				{
					continue;
				}
				PlayerControllerB npc = lethalBotAI.NpcController.Npc;
				if ((Object)(object)npc == (Object)null || npc.isPlayerDead)
				{
					continue;
				}
				bool flag = false;
				float num = Mathf.Max(npc.timeSinceTakingDamage, npc.timeSinceFearLevelUp);
				if (num > 12f)
				{
					if (npc.isInsideFactory && Physics.CheckSphere(((Component)npc).transform.position, 20f, 524288, (QueryTriggerInteraction)2))
					{
						flag = true;
						Plugin.LogDebug("Can't show ad client; 1");
					}
				}
				else if (num < 1.7f && npc.isInsideFactory && Physics.CheckSphere(((Component)npc).transform.position, 12f, 524288, (QueryTriggerInteraction)2))
				{
					flag = true;
					Plugin.LogDebug("Can't show ad client; 2");
				}
				__instance.ReceiveInfoFromClientForShowingAdServerRpc(flag);
			}
		}
	}
}
namespace LethalBots.Patches.EnemiesPatches
{
	[HarmonyPatch(typeof(BaboonBirdAI))]
	public class BaboonBirdAIPatch
	{
	}
	[HarmonyPatch(typeof(BlobAI))]
	[HarmonyAfter(new string[] { "me.swipez.melonloader.morecompany" })]
	public class BlobAIPatch
	{
		[HarmonyPatch("OnCollideWithPlayer")]
		[HarmonyTranspiler]
		public static IEnumerable<CodeInstruction> OnCollideWithPlayer_Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator generator)
		{
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Expected O, but got Unknown
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Expected O, but got Unknown
			int num = -1;
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			for (int i = 0; i < list.Count - 1; i++)
			{
				if (((object)list[i]).ToString().StartsWith("ldloc.0 NULL") && ((object)list[i + 1]).ToString().StartsWith("ldc.i4.s 35"))
				{
					num = i;
					break;
				}
			}
			if (num > -1)
			{
				list[num + 1].opcode = OpCodes.Nop;
				list[num + 1].operand = null;
				List<CodeInstruction> collection = new List<CodeInstruction>
				{
					new CodeInstruction(OpCodes.Ldloc_0, (object)null),
					new CodeInstruction(OpCodes.Callvirt, (object)PatchesUtil.GetDamageFromSlimeIfLethalBotMethod)
				};
				list.InsertRange(num + 1, collection);
				num = -1;
			}
			else
			{
				Plugin.LogError("LethalBot.Patches.EnemiesPatches.BlobAIPatch.OnCollideWithPlayer_Transpiler could not change default damage to bot.");
			}
			return list.AsEnumerable();
		}
	}
	[HarmonyPatch(typeof(BushWolfEnemy))]
	public class BushWolfEnemyPatch
	{
		[HarmonyPatch("OnCollideWithPlayer")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> OnCollideWithPlayer_Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator generator)
		{
			int num = -1;
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			MethodInfo methodInfo = AccessTools.PropertyGetter(typeof(GameNetworkManager), "Instance");
			FieldInfo fieldInfo = AccessTools.Field(typeof(GameNetworkManager), "localPlayerController");
			MethodInfo methodInfo2 = AccessTools.Method(typeof(Object), "op_Equality", (Type[])null, (Type[])null);
			for (int i = 0; i < list.Count - 4; i++)
			{
				if (CodeInstructionExtensions.IsLdarg(list[i], (int?)0) && CodeInstructionExtensions.LoadsField(list[i + 1], PatchesUtil.FieldInfoTargetPlayer, false) && CodeInstructionExtensions.Calls(list[i + 2], methodInfo) && CodeInstructionExtensions.LoadsField(list[i + 3], fieldInfo, false) && CodeInstructionExtensions.Calls(list[i + 4], methodInfo2))
				{
					num = i;
					break;
				}
			}
			if (num > -1)
			{
				list[num + 2].opcode = OpCodes.Nop;
				list[num + 2].operand = null;
				list[num + 3].opcode = OpCodes.Nop;
				list[num + 3].operand = null;
				list[num + 4].opcode = OpCodes.Call;
				list[num + 4].operand = PatchesUtil.IsPlayerLocalOrLethalBotOwnerLocalMethod;
				num = -1;
			}
			else
			{
				Plugin.LogError("LethalBot.Patches.EnemiesPatches.BushWolfEnemyPatch.OnCollideWithPlayer_Transpiler could not check if bot or local player!");
			}
			for (int j = 0; j < list.Count - 1; j++)
			{
				if (CodeInstructionExtensions.Calls(list[j], methodInfo) && CodeInstructionExtensions.LoadsField(list[j + 1], fieldInfo, false))
				{
					num = j;
					break;
				}
			}
			if (num > -1)
			{
				list[num].opcode = OpCodes.Ldarg_0;
				list[num].operand = null;
				list[num + 1].opcode = OpCodes.Ldfld;
				list[num + 1].operand = PatchesUtil.FieldInfoTargetPlayer;
				num = -1;
			}
			else
			{
				Plugin.LogError("LethalBot.Patches.EnemiesPatches.BushWolfEnemyPatch.OnCollideWithPlayer_Transpiler could not replace GameNetworkManager.Instance.localPlayerController with targetPlayer field!");
			}
			return list.AsEnumerable();
		}

		[HarmonyPatch("Update")]
		[HarmonyTranspiler]
		public static IEnumerable<CodeInstruction> Update_Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator generator)
		{
			int num = -1;
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			MethodInfo methodInfo = AccessTools.PropertyGetter(typeof(GameNetworkManager), "Instance");
			FieldInfo fieldInfo = AccessTools.Field(typeof(GameNetworkManager), "localPlayerController");
			MethodInfo methodInfo2 = AccessTools.Method(typeof(Object), "op_Equality", (Type[])null, (Type[])null);
			MethodInfo methodInfo3 = AccessTools.Method(typeof(PlayerControllerB), "JumpToFearLevel", (Type[])null, (Type[])null);
			for (int i = 0; i < list.Count - 4; i++)
			{
				if (CodeInstructionExtensions.Calls(list[i], methodInfo) && CodeInstructionExtensions.LoadsField(list[i + 1], fieldInfo, false) && CodeInstructionExtensions.IsLdarg(list[i + 2], (int?)0) && CodeInstructionExtensions.LoadsField(list[i + 3], PatchesUtil.FieldInfoTargetPlayer, false) && CodeInstructionExtensions.Calls(list[i + 4], methodInfo2))
				{
					num = i;
					break;
				}
			}
			if (num > -1)
			{
				list[num].opcode = OpCodes.Nop;
				list[num].operand = null;
				list[num + 1].opcode = OpCodes.Nop;
				list[num + 1].operand = null;
				list[num + 2].opcode = OpCodes.Ldarg_0;
				list[num + 2].operand = null;
				list[num + 3].opcode = OpCodes.Ldfld;
				list[num + 3].operand = PatchesUtil.FieldInfoTargetPlayer;
				list[num + 4].opcode = OpCodes.Call;
				list[num + 4].operand = PatchesUtil.IsPlayerLocalOrLethalBotOwnerLocalMethod;
				num = -1;
			}
			else
			{
				Plugin.LogError("LethalBot.Patches.EnemiesPatches.BushWolfEnemyPatch.Update_Transpiler could not check if bot or local player 1");
			}
			for (int j = 0; j < list.Count - 4; j++)
			{
				if (CodeInstructionExtensions.Calls(list[j], methodInfo) && CodeInstructionExtensions.LoadsField(list[j + 1], fieldInfo, false) && CodeInstructionExtensions.IsLdarg(list[j + 2], (int?)0) && CodeInstructionExtensions.LoadsField(list[j + 3], PatchesUtil.FieldInfoDraggingPlayer, false) && CodeInstructionExtensions.Calls(list[j + 4], methodInfo2))
				{
					num = j;
					break;
				}
			}
			if (num > -1)
			{
				list[num].opcode = OpCodes.Nop;
				list[num].operand = null;
				list[num + 1].opcode = OpCodes.Nop;
				list[num + 1].operand = null;
				list[num + 2].opcode = OpCodes.Ldarg_0;
				list[num + 2].operand = null;
				list[num + 3].opcode = OpCodes.Ldfld;
				list[num + 3].operand = PatchesUtil.FieldInfoDraggingPlayer;
				list[num + 4].opcode = OpCodes.Call;
				list[num + 4].operand = PatchesUtil.IsPlayerLocalOrLethalBotOwnerLocalMethod;
				num = -1;
			}
			else
			{
				Plugin.LogError("LethalBot.Patches.EnemiesPatches.BushWolfEnemyPatch.Update_Transpiler could not check if bot or local player 2");
			}
			for (int k = 0; k < list.Count - 4; k++)
			{
				if (CodeInstructionExtensions.Calls(list[k], methodInfo) && CodeInstructionExtensions.LoadsField(list[k + 1], fieldInfo, false) && CodeInstructionExtensions.IsLdarg(list[k + 2], (int?)0) && CodeInstructionExtensions.LoadsField(list[k + 3], PatchesUtil.FieldInfoTargetPlayer, false) && CodeInstructionExtensions.Calls(list[k + 4], methodInfo2))
				{
					num = k;
					break;
				}
			}
			if (num > -1)
			{
				list[num].opcode = OpCodes.Nop;
				list[num].operand = null;
				list[num + 1].opcode = OpCodes.Nop;
				list[num + 1].operand = null;
				list[num + 2].opcode = OpCodes.Ldarg_0;
				list[num + 2].operand = null;
				list[num + 3].opcode = OpCodes.Ldfld;
				list[num + 3].operand = PatchesUtil.FieldInfoTargetPlayer;
				list[num + 4].opcode = OpCodes.Call;
				list[num + 4].operand = PatchesUtil.IsPlayerLocalOrLethalBotOwnerLocalMethod;
				num = -1;
			}
			else
			{
				Plugin.LogError("LethalBot.Patches.EnemiesPatches.BushWolfEnemyPatch.Update_Transpiler could not check if bot or local player 3");
			}
			for (int l = 0; l < list.Count - 4; l++)
			{
				if (CodeInstructionExtensions.Calls(list[l], methodInfo) && CodeInstructionExtensions.LoadsField(list[l + 1], fieldInfo, false) && list[l + 2].opcode == OpCodes.Ldc_R4 && list[l + 2].operand is float num2 && num2 == 1f && list[l + 3].opcode == OpCodes.Ldc_I4_1 && CodeInstructionExtensions.Calls(list[l + 4], methodInfo3))
				{
					num = l;
					break;
				}
			}
			if (num > -1)
			{
				list[num].opcode = OpCodes.Ldarg_0;
				list[num].operand = null;
				list[num + 1].opcode = OpCodes.Ldfld;
				list[num + 1].operand = PatchesUtil.FieldInfoTargetPlayer;
				num = -1;
			}
			else
			{
				Plugin.LogError("LethalBot.Patches.EnemiesPatches.BushWolfEnemyPatch.Update_Transpiler could not use target player for JumpToFearLevel method");
			}
			for (int m = 0; m < list.Count - 4; m++)
			{
				if (CodeInstructionExtensions.Calls(list[m], methodInfo) && CodeInstructionExtensions.LoadsField(list[m + 1], fieldInfo, false) && CodeInstructionExtensions.IsLdarg(list[m + 2], (int?)0) && CodeInstructionExtensions.LoadsField(list[m + 3], PatchesUtil.FieldInfoTargetPlayer, false) && CodeInstructionExtensions.Calls(list[m + 4], methodInfo2))
				{
					num = m;
					break;
				}
			}
			if (num > -1)
			{
				list[num].opcode = OpCodes.Nop;
				list[num].operand = null;
				list[num + 1].opcode = OpCodes.Nop;
				list[num + 1].operand = null;
				list[num + 2].opcode = OpCodes.Ldarg_0;
				list[num + 2].operand = null;
				list[num + 3].opcode = OpCodes.Ldfld;
				list[num + 3].operand = PatchesUtil.FieldInfoTargetPlayer;
				list[num + 4].opcode = OpCodes.Call;
				list[num + 4].operand = PatchesUtil.IsPlayerLocalOrLethalBotOwnerLocalMethod;
				num = -1;
			}
			else
			{
				Plugin.LogError("LethalBot.Patches.EnemiesPatches.BushWolfEnemyPatch.Update_Transpiler could not check if bot or local player 4");
			}
			for (int n = 0; n < list.Count - 4; n++)
			{
				if (CodeInstructionExtensions.Calls(list[n], methodInfo) && CodeInstructionExtensions.LoadsField(list[n + 1], fieldInfo, false) && CodeInstructionExtensions.IsLdarg(list[n + 2], (int?)0) && CodeInstructionExtensions.LoadsField(list[n + 3], PatchesUtil.FieldInfoTargetPlayer, false) && CodeInstructionExtensions.Calls(list[n + 4], methodInfo2))
				{
					num = n;
					break;
				}
			}
			if (num > -1)
			{
				list[num].opcode = OpCodes.Nop;
				list[num].operand = null;
				list[num + 1].opcode = OpCodes.Nop;
				list[num + 1].operand = null;
				list[num + 2].opcode = OpCodes.Ldarg_0;
				list[num + 2].operand = null;
				list[num + 3].opcode = OpCodes.Ldfld;
				list[num + 3].operand = PatchesUtil.FieldInfoTargetPlayer;
				list[num + 4].opcode = OpCodes.Call;
				list[num + 4].operand = PatchesUtil.IsPlayerLocalOrLethalBotOwnerLocalMethod;
				num = -1;
			}
			else
			{
				Plugin.LogError("LethalBot.Patches.EnemiesPatches.BushWolfEnemyPatch.Update_Transpiler could not check if bot or local player 5");
			}
			for (int num3 = 0; num3 < list.Count - 4; num3++)
			{
				if (CodeInstructionExtensions.IsLdarg(list[num3], (int?)0) && CodeInstructionExtensions.LoadsField(list[num3 + 1], PatchesUtil.FieldInfoTargetPlayer, false) && CodeInstructionExtensions.Calls(list[num3 + 2], methodInfo) && CodeInstructionExtensions.LoadsField(list[num3 + 3], fieldInfo, false) && CodeInstructionExtensions.Calls(list[num3 + 4], methodInfo2))
				{
					num = num3;
					break;
				}
			}
			if (num > -1)
			{
				list[num].opcode = OpCodes.Nop;
				list[num].operand = null;
				list[num + 1].opcode = OpCodes.Nop;
				list[num + 1].operand = null;
				list[num + 2].opcode = OpCodes.Ldarg_0;
				list[num + 2].operand = null;
				list[num + 3].opcode = OpCodes.Ldfld;
				list[num + 3].operand = PatchesUtil.FieldInfoTargetPlayer;
				list[num + 4].opcode = OpCodes.Call;
				list[num + 4].operand = PatchesUtil.IsPlayerLocalOrLethalBotOwnerLocalMethod;
				num = -1;
			}
			else
			{
				Plugin.LogError("LethalBot.Patches.EnemiesPatches.BushWolfEnemyPatch.Update_Transpiler could not check if bot or local player 6");
			}
			for (int num4 = 0; num4 < list.Count - 18; num4++)
			{
				if (CodeInstructionExtensions.Calls(list[num4], methodInfo) && CodeInstructionExtensions.LoadsField(list[num4 + 1], fieldInfo, false) && CodeInstructionExtensions.Calls(list[num4 + 17], methodInfo) && CodeInstructionExtensions.LoadsField(list[num4 + 18], fieldInfo, false))
				{
					num = num4;
					break;
				}
			}
			if (num > -1)
			{
				list[num].opcode = OpCodes.Ldarg_0;
				list[num].operand = null;
				list[num + 1].opcode = OpCodes.Ldfld;
				list[num + 1].operand = PatchesUtil.FieldInfoTargetPlayer;
				list[num + 17].opcode = OpCodes.Ldarg_0;
				list[num + 17].operand = null;
				list[num + 18].opcode = OpCodes.Ldfld;
				list[num + 18].operand = PatchesUtil.FieldInfoTargetPlayer;
				num = -1;
			}
			else
			{
				Plugin.LogError("LethalBot.Patches.EnemiesPatches.BushWolfEnemyPatch.Update_Transpiler could not use target player for check if HitByEnemyServerRpc method");
			}
			return list.AsEnumerable();
		}
	}
	[HarmonyPatch(typeof(ButlerBeesEnemyAI))]
	public class ButlerBeesEnemyAIPatch
	{
		[HarmonyPatch("OnCollideWithPlayer")]
		[HarmonyTranspiler]
		public static IEnumerable<CodeInstruction> OnCollideWithPlayer_Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator generator)
		{
			int num = -1;
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			for (int i = 0; i < list.Count - 2; i++)
			{
				if (((object)list[i]).ToString() == "ldloc.0 NULL" && ((object)list[i + 2]).ToString() == "ldfld GameNetcodeStuff.PlayerControllerB GameNetworkManager::localPlayerController")
				{
					num = i;
					break;
				}
			}
			if (num > -1)
			{
				list[num + 1].opcode = OpCodes.Nop;
				list[num + 1].operand = null;
				list[num + 2].opcode = OpCodes.Call;
				list[num + 2].operand = PatchesUtil.IsPlayerLocalOrLethalBotOwnerLocalMethod;
				list[num + 3].opcode = OpCodes.Nop;
				list[num + 3].operand = null;
				num = -1;
			}
			else
			{
				Plugin.LogError("LethalBot.Patches.EnemiesPatches.ButlerBeesEnemyAIPatch.OnCollideWithPlayer_Transpiler could not check if local player or bot owner local player");
			}
			return list.AsEnumerable();
		}
	}
	[HarmonyPatch(typeof(ButlerEnemyAI))]
	public class ButlerEnemyAIPatch
	{
		[HarmonyPatch("OnCollideWithPlayer")]
		[HarmonyTranspiler]
		public static IEnumerable<CodeInstruction> OnCollideWithPlayer_Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator generator)
		{
			int num = -1;
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			for (int i = 0; i < list.Count - 2; i++)
			{
				if (((object)list[i]).ToString() == "ldloc.0 NULL" && ((object)list[i + 2]).ToString() == "ldfld GameNetcodeStuff.PlayerControllerB GameNetworkManager::localPlayerController")
				{
					num = i;
					break;
				}
			}
			if (num > -1)
			{
				list[num + 1].opcode = OpCodes.Nop;
				list[num + 1].operand = null;
				list[num + 2].opcode = OpCodes.Call;
				list[num + 2].operand = PatchesUtil.IsPlayerLocalOrLethalBotOwnerLocalMethod;
				list[num + 3].opcode = OpCodes.Nop;
				list[num + 3].operand = null;
				num = -1;
			}
			else
			{
				Plugin.LogError("LethalBot.Patches.EnemiesPatches.ButlerEnemyAIPatch.OnCollideWithPlayer_Transpiler could not check if local player or bot owner local player");
			}
			return list.AsEnumerable();
		}

		[HarmonyPatch("DoAIInterval")]
		[HarmonyTranspiler]
		public static IEnumerable<CodeInstruction> DoAIInterval_Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator generator)
		{
			//IL_018d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0199: Expected O, but got Unknown
			//IL_01a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b0: Expected O, but got Unknown
			//IL_01bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c5: Expected O, but got Unknown
			//IL_01cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d6: Expected O, but got Unknown
			//IL_01dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e7: 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");
			MethodInfo methodInfo2 = AccessTools.Method(typeof(Object), "op_Inequality", (Type[])null, (Type[])null);
			FieldInfo fieldInfo2 = AccessTools.Field(typeof(EnemyAI), "targetPlayer");
			Plugin.LogDebug("Beginning to patch ButlerEnemyAI.DoAIInterval!");
			for (int i = 0; i < list.Count - 4; i++)
			{
				if (CodeInstructionExtensions.Calls(list[i], methodInfo) && CodeInstructionExtensions.LoadsField(list[i + 1], fieldInfo, false) && CodeInstructionExtensions.IsLdarg(list[i + 2], (int?)0) && CodeInstructionExtensions.LoadsField(list[i + 3], fieldInfo2, false) && CodeInstructionExtensions.Calls(list[i + 4], methodInfo2))
				{
					Plugin.LogDebug($"Patching localPlayerController comparison at index {i}...");
					Plugin.LogDebug($"Original Codes: 1: {list[i]}, 2: {list[i + 1]}, 3: {list[i + 2]}, 4: {list[i + 3]}, 5: {list[i + 4]}");
					num = i;
					break;
				}
			}
			if (num != -1)
			{
				List<Label> labels = list[num].labels;
				list.RemoveRange(num, 5);
				List<CodeInstruction> collection = new List<CodeInstruction>
				{
					CodeInstructionExtensions.WithLabels(new CodeInstruction(OpCodes.Ldarg_0, (object)null), (IEnumerable<Label>)labels),
					new CodeInstruction(OpCodes.Ldfld, (object)fieldInfo2),
					new CodeInstruction(OpCodes.Call, (object)PatchesUtil.IsPlayerLocalOrLethalBotOwnerLocalMethod),
					new CodeInstruction(OpCodes.Ldc_I4_0, (object)null),
					new CodeInstruction(OpCodes.Ceq, (object)null)
				};
				list.InsertRange(num, collection);
				num = -1;
			}
			else
			{
				Plugin.LogError("LethalBot.Patches.EnemyPatches.ButlerEnemyAI.DoAIInterval_Transpiler could not find the localPlayerController reference!");
			}
			Plugin.LogDebug("Finished patching ButlerEnemyAI.DoAIInterval!");
			return list.AsEnumerable();
		}
	}
	[HarmonyPatch(typeof(CadaverBloomAI))]
	public class CadaverBloomAIPatch
	{
		[HarmonyPatch("OnCollideWithPlayer")]
		[HarmonyTranspiler]
		public static IEnumerable<CodeInstruction> OnCollideWithPlayer_Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator generator)
		{
			int num = -1;
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			MethodInfo methodInfo = AccessTools.PropertyGetter(typeof(GameNetworkManager), "Instance");
			FieldInfo fieldInfo = AccessTools.Field(typeof(GameNetworkManager), "localPlayerController");
			MethodInfo methodInfo2 = AccessTools.Method(typeof(PlayerControllerB), "JumpToFearLevel", (Type[])null, (Type[])null);
			for (int i = 0; i < list.Count - 4; i++)
			{
				if (CodeInstructionExtensions.Calls(list[i], methodInfo) && CodeInstructionExtensions.LoadsField(list[i + 1], fieldInfo, false) && list[i + 2].opcode == OpCodes.Ldc_R4 && list[i + 2].operand is float num2 && num2 == 1f && list[i + 3].opcode == OpCodes.Ldc_I4_1 && CodeInstructionExtensions.Calls(list[i + 4], methodInfo2))
				{
					num = i;
					break;
				}
			}
			if (num > -1)
			{
				list[num].opcode = OpCodes.Nop;
				list[num].operand = null;
				list[num + 1].opcode = OpCodes.Ldloc_0;
				list[num + 1].operand = null;
				num = -1;
			}
			else
			{
				Plugin.LogError("LethalBot.Patches.EnemiesPatches.OnOnCollideWithPlayer_Transpiler could not replace localPlayerController with locally cached player");
			}
			return list.AsEnumerable();
		}

		[HarmonyPatch("Update")]
		[HarmonyPostfix]
		public static void Update_Postfix(CadaverBloomAI __instance, ref bool ___lostPlayerInChase, ref float ___seePlayerMeter, ref float ___timeAtLastHeardNoise, ref float ___timeAtLastHitStun)
		{
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Invalid comparison between Unknown and I4
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			if (((EnemyAI)__instance).isEnemyDead || ((EnemyAI)__instance).inSpecialAnimation)
			{
				return;
			}
			UpdateLimiter orCreateMonitor = UpdateLimiter.GetOrCreateMonitor((EnemyAI)(object)__instance);
			if (!orCreateMonitor.CanUpdate())
			{
				return;
			}
			orCreateMonitor.Invalidate();
			bool flag = Time.realtimeSinceStartup - ___timeAtLastHeardNoise < 1.5f;
			bool flag2 = Time.realtimeSinceStartup - ___timeAtLastHitStun < 0.75f;
			if ((flag && (___lostPlayerInChase || ___seePlayerMeter < 0.07f)) || flag2 || ((EnemyAI)__instance).stunNormalizedTimer > 0f)
			{
				return;
			}
			int num = 18;
			if ((int)TimeOfDay.Instance.currentLevelWeather == 3)
			{
				num = 8;
			}
			LethalBotAI[] lethalBotsAIOwnedByLocal = LethalBotManager.Instance.GetLethalBotsAIOwnedByLocal();
			LethalBotAI[] array = lethalBotsAIOwnedByLocal;
			for (int i = 0; i < array.Length; i++)
			{
				PlayerControllerB val = array[i]?.NpcController?.Npc;
				if ((Object)(object)val != (Object)null && val.HasLineOfSightToPosition(((Component)__instance).transform.position + Vector3.up * 0.25f, 80f, num, 5f, -1))
				{
					if (((EnemyAI)__instance).currentBehaviourStateIndex == 1 && !___lostPlayerInChase)
					{
						val.IncreaseFearLevelOverTime(0.8f, 0.7f);
					}
					else
					{
						val.IncreaseFearLevelOverTime(0.8f, 0.3f);
					}
				}
			}
		}

		[HarmonyPatch("BurstForth")]
		[HarmonyTranspiler]
		public static IEnumerable<CodeInstruction> BurstForth_Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator generator)
		{
			int num = -1;
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			MethodInfo methodInfo = AccessTools.PropertyGetter(typeof(GameNetworkManager), "Instance");
			FieldInfo fieldInfo = AccessTools.Field(typeof(GameNetworkManager), "localPlayerController");
			MethodInfo methodInfo2 = AccessTools.Method(typeof(Object), "op_Equality", (Type[])null, (Type[])null);
			for (int i = 0; i < list.Count - 2; i++)
			{
				if (CodeInstructionExtensions.Calls(list[i], methodInfo) && CodeInstructionExtensions.LoadsField(list[i + 1], fieldInfo, false) && CodeInstructionExtensions.Calls(list[i + 2], methodInfo2))
				{
					num = i;
					break;
				}
			}
			if (num > -1)
			{
				list[num].opcode = OpCodes.Nop;
				list[num].operand = null;
				list[num + 1].opcode = OpCodes.Nop;
				list[num + 1].operand = null;
				list[num + 2].opcode = OpCodes.Call;
				list[num + 2].operand = PatchesUtil.IsPlayerLocalOrLethalBotOwnerLocalMethod;
				num = -1;
			}
			else
			{
				Plugin.LogError("LethalBot.Patches.EnemiesPatches.BurstForth_Transpiler could not change kill local player comparison to consider bots as well");
			}
			return list.AsEnumerable();
		}
	}
	[HarmonyPatch(typeof(CadaverGrowthAI))]
	public class CadaverGrowthAIPatch
	{
		[CompilerGenerated]
		private sealed class <BurstFromPlayerCoroutine>d__14 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public CadaverGrowthAI cadaver;

			public PlayerControllerB player;

			public int infectedNum;

			private PlayerInfection <playerInfection>5__2;

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

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

			[DebuggerHidden]
			public <BurstFromPlayerCoroutine>d__14(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<playerInfection>5__2 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0058: Unknown result type (might be due to invalid IL or missing references)
				//IL_0062: Expected O, but got Unknown
				//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
				//IL_0127: Unknown result type (might be due to invalid IL or missing references)
				//IL_0137: Unknown result type (might be due to invalid IL or missing references)
				//IL_015e: Unknown result type (might be due to invalid IL or missing references)
				//IL_016e: Unknown result type (might be due to invalid IL or missing references)
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<playerInfection>5__2 = cadaver.playerInfections[player.playerClientId];
					<>2__current = null;
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<>2__current = (object)new WaitForEndOfFrame();
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					if ((Object)(object)player != (Object)null && player.isPlayerControlled && !player.isPlayerDead && <playerInfection>5__2.infected && <playerInfection>5__2.infectionMeter > 0.85f && StartOfRound.Instance.livingPlayers > 1 && Vector3.Distance(((Component)player).transform.position, ((Component)cadaver.bloomEnemies[infectedNum]).transform.position) < 14f)
					{
						cadaver.BurstFromPlayer(player, ((Component)player).transform.position, ((Component)player).transform.eulerAngles);
						cadaver.SyncBurstFromPlayerRpc((int)player.playerClientId, ((Component)player).transform.position, ((Component)player).transform.eulerAngles);
					}
					return false;
				}
			}

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

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

		private static MethodInfo displayFeverStatusEffectMethod = AccessTools.Method(typeof(CadaverGrowthAI), "DisplayFeverStatusEffect", (Type[])null, (Type[])null);

		private static MethodInfo increaseBackFlowersMethod = AccessTools.Method(typeof(CadaverGrowthAI), "IncreaseBackFlowers", (Type[])null, (Type[])null);

		private static MethodInfo healPlayerSporeEffectMethod = AccessTools.Method(typeof(CadaverGrowthAI), "HealPlayerSporeEffect", (Type[])null, (Type[])null);

		private static readonly UpdateLimiter nextCadaverGrowthCheck = new UpdateLimiter();

		[CompilerGenerated]
		private static CadaverGrowthAI? <CadaverGrowthAI>k__BackingField;

		internal static CadaverGrowthAI? CadaverGrowthAI
		{
			get
			{
				if ((Object)(object)<CadaverGrowthAI>k__BackingField == (Object)null && nextCadaverGrowthCheck.CanUpdate())
				{
					nextCadaverGrowthCheck.Invalidate();
					<CadaverGrowthAI>k__BackingField = Object.FindObjectOfType<CadaverGrowthAI>();
				}
				return <CadaverGrowthAI>k__BackingField;
			}
			set
			{
				<CadaverGrowthAI>k__BackingField = value;
			}
		}

		[HarmonyPatch("OnEnable")]
		[HarmonyPostfix]
		public static void OnEnable_Postfix(CadaverGrowthAI __instance)
		{
			CadaverGrowthAI = __instance;
			((UnityEvent<LethalBotVoice, float>)(object)LethalBotVoice.lethalBotTalkEvent).AddListener((UnityAction<LethalBotVoice, float>)OnLethalBotTalk);
		}

		[HarmonyPatch("OnDisable")]
		[HarmonyPostfix]
		public static void OnDisable_Postfix(CadaverGrowthAI __instance)
		{
			CadaverGrowthAI = null;
			((UnityEvent<LethalBotVoice, float>)(object)LethalBotVoice.lethalBotTalkEvent).RemoveListener((UnityAction<LethalBotVoice, float>)OnLethalBotTalk);
			PlayerControllerB localPlayerController = GameNetworkManager.Instance.localPlayerController;
			for (int i = 0; i < __instance.playerInfections.Length; i++)
			{
				PlayerInfection val = __instance.playerInfections[i];
				PlayerControllerB val2 = StartOfRound.Instance.allPlayerScripts[i];
				if ((Object)(object)val2 != (Object)null && (Object)(object)val2 != (Object)(object)localPlayerController && LethalBotManager.Instance.IsPlayerLethalBot(val2) && val.hinderingPlayerMovement)
				{
					val2.isMovementHindered--;
					if (val2.overridePoisonValue)
					{
						val2.overridePoisonValue = false;
					}
					val.hinderingPlayerMovement = false;
				}
			}
		}

		private static void OnLethalBotTalk(LethalBotVoice botVoice, float loudness)
		{
			//IL_014d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0167: Unknown result type (might be due to invalid IL or missing references)
			//IL_017c: Unknown result type (might be due to invalid IL or missing references)
			//IL_018c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0196: Unknown result type (might be due to invalid IL or missing references)
			//IL_019b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c5: Unknown result type (might be due to invalid IL or missing references)
			LethalBotAI lethalBotAI = LethalBotManager.Instance.GetLethalBotAI(botVoice.BotID);
			if ((Object)(object)lethalBotAI == (Object)null || (Object)(object)CadaverGrowthAI == (Object)null)
			{
				return;
			}
			PlayerControllerB npc = lethalBotAI.NpcController.Npc;
			PlayerInfection val = CadaverGrowthAI.playerInfections[npc.playerClientId];
			Plugin.LogDebug("On Lethal Bot talk " + npc.playerUsername + "!");
			if (!val.infected)
			{
				return;
			}
			Plugin.LogDebug($"On Lethal Bot talk! B ; {val.infectionMeter} ; {val.emittingSpores}!");
			if (val.infectionMeter > 0.6f && (val.emittingSpores || Random.Range(0, 1000) < 10))
			{
				Plugin.LogDebug($"On Lethal Bot talk! C {(Object)(object)val.backFlowers == (Object)null}; {(Object)(object)val.faceSpores == (Object)null}!");
				if ((Object)(object)val.backFlowers != (Object)null && (Object)(object)val.faceSpores != (Object)null)
				{
					val.faceSpores.SetFloat("BurstAmount", Mathf.Lerp(370f, 700f, loudness));
					val.faceSporesOutput = 0.16f;
					((Component)val.faceSpores).transform.position = ((Component)npc.gameplayCamera).transform.position;
					Plugin.LogDebug($"Face spore object position: {((Component)npc.gameplayCamera).transform.position}; {((Component)npc.gameplayCamera).transform.position + ((Component)npc.gameplayCamera).transform.forward * 0.25f}");
					((Component)val.faceSpores).transform.rotation = ((Component)npc.gameplayCamera).transform.rotation;
					val.faceSpores.Play();
					CadaverGrowthAI.CoughSporesRpc(loudness, (int)npc.playerClientId);
				}
			}
		}

		[HarmonyPatch("OnLocalPlayerDie")]
		[HarmonyTranspiler]
		public static IEnumerable<CodeInstruction> OnLocalPlayerDie_Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator generator)
		{
			int num = -1;
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			MethodInfo methodInfo = AccessTools.PropertyGetter(typeof(GameNetworkManager), "Instance");
			FieldInfo fieldInfo = AccessTools.Field(typeof(GameNetworkManager), "localPlayerController");
			for (int i = 0; i < list.Count - 1; i++)
			{
				if (CodeInstructionExtensions.Calls(list[i], methodInfo) && CodeInstructionExtensions.LoadsField(list[i + 1], fieldInfo, false))
				{
					num = i;
					break;
				}
			}
			if (num > -1)
			{
				list[num].opcode = OpCodes.Nop;
				list[num].operand = null;
				list[num + 1].opcode = OpCodes.Ldarg_1;
				list[num + 1].operand = null;
				num = -1;
			}
			else
			{
				Plugin.LogError("LethalBot.Patches.EnemiesPatches.OnLocalPlayerDie_Transpiler could not replace localPlayerController with locally cached player");
			}
			return list.AsEnumerable();
		}

		[HarmonyPatch("CoughSporesRpc")]
		[HarmonyPostfix]
		public static void CoughSporesRpc_Postfix(CadaverGrowthAI __instance, float loudness, int playerId)
		{
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			PlayerControllerB val = StartOfRound.Instance.allPlayerScripts[playerId];
			LethalBotAI[] lethalBotsAIOwnedByLocal = LethalBotManager.Instance.GetLethalBotsAIOwnedByLocal();
			LethalBotAI[] array = lethalBotsAIOwnedByLocal;
			for (int i = 0; i < array.Length; i++)
			{
				PlayerControllerB val2 = array[i]?.NpcController?.Npc;
				if (!((Object)(object)val2 != (Object)null) || !(val.LineOfSightToPositionAngle(((Component)val2.gameplayCamera).transform.position, 12, 0f, -1) < 30f))
				{
					continue;
				}
				float num = Vector3.Distance(((Component)val2).transform.position, ((Component)val).transform.position);
				if ((float)Random.Range(0, 1000) < Mathf.Lerp(50f, 1f, Mathf.Clamp(num * num / 60f, 0f, 1f)))
				{
					bool flag = false;
					if (Random.Range(0, 100) < 70)
					{
						flag = true;
					}
					bool flag2 = flag || Random.Range(0, 100) < 40;
					__instance.InfectPlayer(val2, flag, flag2);
					__instance.InfectPlayerRpc((int)val2.playerClientId, flag, flag2);
				}
			}
		}

		[HarmonyPatch("InfectPlayers")]
		[HarmonyPostfix]
		public static void InfectPlayers_Postfix(CadaverGrowthAI __instance, ref int ___numberOfInfected)
		{
			//IL_0132: Unknown result type (might be due to invalid IL or missing references)
			//IL_014b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0150: Unknown result type (might be due to invalid IL or missing references)
			//IL_0155: Unknown result type (might be due to invalid IL or missing references)
			//IL_0299: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0217: Unknown result type (might be due to invalid IL or missing references)
			//IL_0223: Unknown result type (might be due to invalid IL or missing references)
			LethalBotAI[] lethalBotsAIOwnedByLocal = LethalBotManager.Instance.GetLethalBotsAIOwnedByLocal();
			LethalBotAI[] array = lethalBotsAIOwnedByLocal;
			foreach (LethalBotAI lethalBotAI in array)
			{
				if ((Object)(object)lethalBotAI == (Object)null)
				{
					continue;
				}
				PlayerControllerB val = lethalBotAI.NpcController?.Npc;
				if (!((Object)(object)val != (Object)null) || !val.isPlayerControlled || val.isPlayerDead || !val.isInsideFactory)
				{
					continue;
				}
				Tile currentTile = lethalBotAI.DunGenTileTracker.currentTile;
				if ((Object)(object)currentTile == (Object)null)
				{
					continue;
				}
				LethalBotInfection value = lethalBotAI.BotInfectionData.Value;
				bool infected = __instance.playerInfections[val.playerClientId].infected;
				bool flag = false;
				bool flag2 = false;
				int index = -1;
				for (int j = 0; j < __instance.GrowthTiles.Count; j++)
				{
					TileWithGrowth val2 = __instance.GrowthTiles[j];
					if ((Object)(object)val2.tile == (Object)(object)currentTile && !val2.eradicated && val2.plantsInTile > 0)
					{
						flag = true;
						flag2 = true;
						index = j;
						break;
					}
				}
				float num = 0f;
				if (flag)
				{
					float num2 = 1000f;
					int num3 = -1;
					float num4 = 0f;
					for (int k = 0; k < __instance.GrowthTiles[index].plantPositions.Count; k++)
					{
						Vector3 val3 = ((Component)val).transform.position - __instance.GrowthTiles[index].plantPositions[k];
						float sqrMagnitude = ((Vector3)(ref val3)).sqrMagnitude;
						if (sqrMagnitude < num2)
						{
							num2 = sqrMagnitude;
							num3 = k;
						}
						if (sqrMagnitude < 100f)
						{
							num4 += 1f;
						}
					}
					num = Mathf.Clamp(Mathf.Lerp(2f, 16f, num4 / (float)__instance.TileCapacity), 0f, 100f);
					num *= __instance.ChanceToInfectMultiplier;
					if (!infected)
					{
						num *= Mathf.Lerp(1f, 0.75f, (float)___numberOfInfected / (float)StartOfRound.Instance.livingPlayers);
					}
					if (num3 != -1)
					{
						float num5 = Vector3.Distance(__instance.GrowthTiles[index].plantPositions[num3], ((Component)val).transform.position);
						num *= Mathf.Lerp(3f, 0.015f, Mathf.Clamp(num5 / 10f, 0f, 1f));
					}
				}
				bool flag3 = false;
				for (int l = 0; l < __instance.playerInfections.Length; l++)
				{
					if (l == (int)val.playerClientId || !__instance.playerInfections[l].infected)
					{
						continue;
					}
					float num6 = Vector3.Distance(((Component)StartOfRound.Instance.allPlayerScripts[l]).transform.position, ((Component)val).transform.position);
					if (num6 < 7f)
					{
						if (!flag && !flag3)
						{
							flag3 = true;
							num = 1.25f;
						}
						float num7 = 0.35f;
						if (flag2)
						{
							num7 = 1f;
						}
						num *= Mathf.Clamp(Mathf.Lerp(2f, 0.35f, Mathf.Clamp(num6 / 7f, 0f, 1f)), num7, 100f);
					}
				}
				if (num >= 1.5f && flag)
				{
					if (num >= 1.9f)
					{
						if (value.stoodInWeedsLastCheck)
						{
							value.localPlayerImmunityTimer += __instance.InfectIntervalTime;
							value.totalTimeSpentInPlants += __instance.InfectIntervalTime;
						}
						value.stoodInWeedsLastCheck = true;
					}
				}
				else if (value.stoodInWeedsLastCheck)
				{
					value.stoodInWeedsLastCheck = false;
					if (__instance.playerInfections[val.playerClientId].infected)
					{
						value.totalTimeSpentInPlants = Mathf.Max(0f, value.totalTimeSpentInPlants - __instance.InfectIntervalTime * 0.25f);
					}
				}
				if (!infected && flag)
				{
					if (val.health == 100)
					{
						num *= 0.75f;
					}
					else if (val.health <= 60)
					{
						num *= 1.2f;
					}
					if (val.criticallyInjured && value.stoodInWeedsLastCheck && num >= 1.9f)
					{
						num *= 1.5f;
					}
					if ((StartOfRound.Instance.connectedPlayersAmount != 0 || !(value.localPlayerImmunityTimer < 7f)) && (StartOfRound.Instance.connectedPlayersAmount <= 0 || !(value.localPlayerImmunityTimer <= 4f)) && Random.Range(0f, 100f) < num)
					{
						bool flag4 = Random.Range(0, 100) < 60;
						bool flag5 = flag4 || Random.Range(0, 100) < 40;
						__instance.InfectPlayer(val, flag4, flag5);
						__instance.InfectPlayerRpc((int)val.playerClientId, flag4, flag5);
					}
				}
			}
		}

		[IteratorStateMachine(typeof(<BurstFromPlayerCoroutine>d__14))]
		private static IEnumerator BurstFromPlayerCoroutine(CadaverGrowthAI cadaver, PlayerControllerB player, int infectedNum)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <BurstFromPlayerCoroutine>d__14(0)
			{
				cadaver = cadaver,
				player = player,
				infectedNum = infectedNum
			};
		}

		[HarmonyPatch("BurstFromPlayer")]
		[HarmonyPrefix]
		public static void BurstFromPlayer_Prefix(CadaverGrowthAI __instance, PlayerControllerB playerScript, Vector3 burstPosition, Vector3 burstRotation)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			int num = -1;
			Vector3 position = ((Component)playerScript).transform.position;
			for (int i = 0; i < __instance.bloomEnemies.Length; i++)
			{
				CadaverBloomAI val = __instance.bloomEnemies[i];
				if ((Object)(object)val != (Object)null && !val.hasBurst)
				{
					num = i;
					break;
				}
			}
			if (num == -1)
			{
				Plugin.LogError("Cadaver growth AI: Tried to burst from player, but there are no bloom enemies on standby? B");
				return;
			}
			LethalBotAI[] lethalBotsAIOwnedByLocal = LethalBotManager.Instance.GetLethalBotsAIOwnedByLocal();
			LethalBotAI[] array = lethalBotsAIOwnedByLocal;
			foreach (LethalBotAI lethalBotAI in array)
			{
				PlayerControllerB val2 = lethalBotAI?.NpcController?.Npc;
				if ((Object)(object)val2 != (Object)null && (Object)(object)val2 != (Object)(object)playerScript && lethalBotAI != null)
				{
					((MonoBehaviour)lethalBotAI).StartCoroutine(BurstFromPlayerCoroutine(__instance, val2, num));
				}
			}
		}

		[HarmonyPatch("HealInfection")]
		[HarmonyPrefix]
		public static bool HealInfection_Prefix(CadaverGrowthAI __instance, int infectionId, float healAmount)
		{
			LethalBotAI lethalBotAI = LethalBotManager.Instance.GetLethalBotAI(infectionId);
			if ((Object)(object)lethalBotAI == (Object)null)
			{
				return true;
			}
			PlayerInfection val = __instance.playerInfections[infectionId];
			LethalBotInfection value = lethalBotAI.BotInfectionData.Value;
			int num = Random.Range(0, __instance.healPlayerSFX.Length);
			healPlayerSporeEffectMethod.Invoke(__instance, new object[2] { infectionId, num });
			val.infectionMeter -= healAmount;
			value.timeAtLastHealing = Time.realtimeSinceStartup;
			value.totalTimeSpentInPlants = Mathf.Clamp(value.totalTimeSpentInPlants - value.totalTimeSpentInPlants / 4f, 0f, 100f);
			if (val.infectionMeter <= 0f)
			{
				__instance.CurePlayer(infectionId);
				__instance.CurePlayerRpc(infectionId);
			}
			else
			{
				__instance.HealInfectionSyncRpc(infectionId, healAmount, num);
			}
			return false;
		}

		[HarmonyPatch("ProgressPlayerInfections")]
		[HarmonyPostfix]
		public static void ProgressPlayerInfections_Postfix(CadaverGrowthAI __instance, ref int ___numberOfInfected)
		{
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01db: Unknown result type (might be due to invalid IL or missing references)
			for (int i = 0; i < __instance.playerInfections.Length; i++)
			{
				PlayerInfection val = __instance.playerInfections[i];
				if (!val.infected)
				{
					continue;
				}
				PlayerControllerB val2 = StartOfRound.Instance.allPlayerScripts[i];
				if (!val2.isPlayerControlled)
				{
					continue;
				}
				LethalBotAI lethalBotAIIfLocalIsOwner = LethalBotManager.Instance.GetLethalBotAIIfLocalIsOwner(val2);
				if ((Object)(object)lethalBotAIIfLocalIsOwner == (Object)null)
				{
					continue;
				}
				LethalBotInfection value = lethalBotAIIfLocalIsOwner.BotInfectionData.Value;
				if (val.infectionMeter >= 1f)
				{
					if (val.burstMeter >= 1f)
					{
						val.infected = false;
						___numberOfInfected--;
						__instance.BurstFromPlayer(val2, ((Component)val2).transform.position, ((Component)val2).transform.eulerAngles);
						__instance.SyncBurstFromPlayerRpc((int)val2.playerClientId, ((Component)val2).transform.position, ((Component)val2).transform.eulerAngles);
						continue;
					}
					val2.poison = Mathf.Lerp(val2.poison, 0f, Time.deltaTime * 0.3f);
					if (val.burstMeter >= 0.9f)
					{
						if (!StartOfRound.Instance.shipIsLeaving)
						{
							if (StartOfRound.Instance.livingPlayers <= 1)
							{
								val.burstMeter += Time.deltaTime * 0.0055f;
							}
							else
							{
								val.burstMeter += Time.deltaTime * 0.068f;
							}
							if (StartOfRound.Instance.connectedPlayersAmount > 0 && !val.hinderingPlayerMovement)
							{
								val2.isMovementHindered++;
								val.hinderingPlayerMovement = true;
							}
						}
						continue;
					}
					float num;
					if (StartOfRound.Instance.connectedPlayersAmount > 0)
					{
						if (StartOfRound.Instance.livingPlayers == 1)
						{
							num = 0.75f;
						}
						else
						{
							float num2 = 2000f;
							for (int j = 0; j < StartOfRound.Instance.allPlayerScripts.Length; j++)
							{
								PlayerControllerB val3 = StartOfRound.Instance.allPlayerScripts[j];
								if ((Object)(object)val3 != (Object)(object)val2)
								{
									float num3 = Vector3.Distance(((Component)val3).transform.position, ((Component)val2).transform.position);
									if (num3 < num2)
									{
										num2 = num3;
									}
								}
							}
							num = 1f;
							num = Mathf.Lerp(3f, 0.015f, Mathf.Clamp(num2 / 30f, 0f, 1f));
						}
					}
					else
					{
						num = 1.25f;
					}
					val.burstMeter += Time.deltaTime * num * __instance.BurstSpeedMultiplier;
					continue;
				}
				if (val.healing > 0)
				{
					val.infectionMeter -= Time.deltaTime * 0.08f * (float)val.healing;
					if (val.infectionMeter <= 0f)
					{
						val.infectionMeter = 0f;
						__instance.CurePlayer(i);
						__instance.CurePlayerRpc(i);
					}
					continue;
				}
				float num4 = 1f;
				bool flag = false;
				if (!val2.isInsideFactory && TimeOfDay.Instance.normalizedTimeOfDay < 0.6f && !Physics.Linecast(((Component)TimeOfDay.Instance.sunDirect).transform.position, ((Component)val2.gameplayCamera).transform.position, StartOfRound.Instance.collidersRoomDefaultAndFoliage, (QueryTriggerInteraction)1))
				{
					flag = true;
				}
				if (flag)
				{
					num4 *= 1.15f;
				}
				if (val2.NearOtherPlayers(15f))
				{
					num4 = ((!(val.infectionMeter > 0.925f)) ? (num4 * 0.7f) : (num4 * 1.5f));
				}
				num4 *= Mathf.Lerp(1f, 0.85f, (float)___numberOfInfected / (float)StartOfRound.Instance.livingPlayers);
				num4 *= 1f + value.totalTimeSpentInPlants / 15f;
				bool flag2 = StartOfRound.Instance.connectedPlayersAmount == 0;
				float num5 = Time.deltaTime * __instance.InfectionSpeedMultiplier * num4 * val.multiplier;
				if (flag2)
				{
					num5 *= 0.45f;
				}
				if (Time.realtimeSinceStartup - value.timeAtLastHealing < 0.7f)
				{
					continue;
				}
				val.infectionMeter = Mathf.Clamp(val.infectionMeter + num5, 0f, 1f);
				value.showSignsMeter += num5;
				if (val.infectionMeter > 0.35f && !flag2)
				{
					val.bloomOnDeath = true;
				}
				if (val2.overridePoisonValue)
				{
					val2.poison = Mathf.Lerp(val2.poison, value.setPoison, Time.deltaTime * 0.7f);
				}
				if (StartOfRound.Instance.connectedPlayersAmount == 0)
				{
					if (value.showSignsMeter > 0.05f)
					{
						value.showSignsMeter = 0f;
						float num6 = (val.infectionMeter - 0.8f) / 0.19999999f;
						val2.overridePoisonValue = true;
						value.setPoison = Mathf.Lerp(0f, 0.4f, num6);
					}
				}
				else if (value.showSignsMeter > 0.05f)
				{
					value.showSignsMeter = 0f;
					float num7 = Mathf.Lerp(5f, 50f, Mathf.Clamp(val.infectionMeter / 0.9f, 0f, 1f));
					if (Random.Range(0f, 100f) < num7)
					{
						increaseBackFlowersMethod.Invoke(__instance, new object[1] { i });
						__instance.IncreaseBackFlowersRpc(i, val.infectionMeter);
					}
					else
					{
						__instance.SyncInfectionMeterRpc((int)val2.playerClientId, val.infectionMeter);
					}
				}
			}
		}

		[HarmonyPatch("InfectPlayer")]
		[HarmonyPostfix]
		public static void InfectPlayer_Postfix(CadaverGrowthAI __instance, PlayerControllerB playerScript)
		{
			LethalBotAI lethalBotAIIfLocalIsOwner = LethalBotManager.Instance.GetLethalBotAIIfLocalIsOwner(playerScript);
			if ((Object)(object)lethalBotAIIfLocalIsOwner != (Object)null)
			{
				lethalBotAIIfLocalIsOwner.BotInfectionData.Value.totalTimeSpentInPlants = 0f;
			}
			LethalBotAI[] lethalBotsAIOwnedByLocal = LethalBotManager.Instance.GetLethalBotsAIOwnedByLocal();
			LethalBotAI[] array = lethalBotsAIOwnedByLocal;
			foreach (LethalBotAI lethalBotAI in array)
			{
				PlayerControllerB val = lethalBotAI?.NpcController?.Npc;
				if ((Object)(object)val != (Object)null && (Object)(object)val != (Object)(object)playerScript && lethalBotAI != null)
				{
					lethalBotAI.BotInfectionData.Value.totalTimeSpentInPlants = 0f;
				}
			}
		}
	}
	[HarmonyPatch(typeof(CaveDwellerAI))]
	public class CaveDwellerAIPatch
	{
		[HarmonyPatch("GetBabyMemoryOfPlayer")]
		[HarmonyReversePatch(/*Could not decode attribute arguments.*/)]
		[HarmonyPriority(0)]
		public static BabyPlayerMemory GetBabyMemoryOfPlayer_ReversePatch(object instance, PlayerControllerB player)
		{
			throw new NotImplementedException("Stub LethalBot.Patches.EnemiesPatches.CaveDwellerAIPatch.GetBabyMemoryOfPlayer");
		}

		[HarmonyPatch("OnCollideWithPlayer")]
		[HarmonyPrefix]
		private static void OnCollideWithPlayer_PreFix(ref bool ___startingKillAnimationLocalClient)
		{
			___startingKillAnimationLocalClient = false;
		}

		[HarmonyPatch("ScareBaby")]
		[HarmonyPostfix]
		private static void ScareBaby_PostFix(CaveDwellerAI __instance)
		{
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			if (((NetworkBehaviour)__instance).IsServer && (!__instance.sittingDown || __instance.holdingBaby) && !((Object)(object)((GrabbableObject)__instance.propScript).playerHeldBy == (Object)null))
			{
				LethalBotAI lethalBotAI = LethalBotManager.Instance.GetLethalBotAI(((GrabbableObject)__instance.propScript).playerHeldBy);
				if (!((Object)(object)lethalBotAI == (Object)null))
				{
					Plugin.LogDebug("ScareBaby_PostFix");
					lethalBotAI.DropItem();
				}
			}
		}

		[HarmonyPatch("ScareBabyClientRpc")]
		[HarmonyPostfix]
		private static void ScareBabyClientRpc_PostFix(CaveDwellerAI __instance)
		{
			//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)
			if (!((NetworkBehaviour)__instance).IsServer && !((Object)(object)((GrabbableObject)__instance.propScript).playerHeldBy == (Object)null))
			{
				LethalBotAI lethalBotAI = LethalBotManager.Instance.GetLethalBotAI(((GrabbableObject)__instance.propScript).playerHeldBy);
				if (!((Object)(object)lethalBotAI == (Object)null))
				{
					Plugin.LogDebug("ScareBabyClientRpc_PostFix");
					lethalBotAI.DropItem();
				}
			}
		}

		[HarmonyPatch("CancelKillAnimationClientRpc")]
		[HarmonyPostfix]
		private static void CancelKillAnimationClientRpc_PostFix(int playerObjectId, ref bool ___startingKillAnimationLocalClient)
		{
			Plugin.LogDebug($"CancelKillAnimationClientRpc_PostFix playerObjectId {playerObjectId}");
			if (LethalBotManager.Instance.IsIdPlayerLethalBotOwnerLocal(playerObjectId))
			{
				Plugin.LogDebug("CancelKillAnimationClientRpc_PostFix");
				___startingKillAnimationLocalClient = false;
			}
		}

		[HarmonyPatch("KillPlayerAnimationClientRpc")]
		[HarmonyTranspiler]
		public static IEnumerable<CodeInstruction> KillPlayerAnimationClientRpc_Transpiler(IEnumerable<CodeInstruction> instructions)
		{
			int num = -1;
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			MethodInfo methodInfo = AccessTools.PropertyGetter(typeof(GameNetworkManager), "Instance");
			FieldInfo fieldInfo = AccessTools.Field(typeof(GameNetworkManager), "localPlayerController");
			MethodInfo methodInfo2 = AccessTools.Method(typeof(Object), "op_Equality", (Type[])null, (Type[])null);
			for (int i = 0; i < list.Count - 3; i++)
			{
				if (list[i].opcode == OpCodes.Ldloc_0 && CodeInstructionExtensions.Calls(list[i + 1], methodInfo) && CodeInstructionExtensions.LoadsField(list[i + 2], fieldInfo, false) && CodeInstructionExtensions.Calls(list[i + 3], methodInfo2))
				{
					num = i;
					break;
				}
			}
			if (num > -1)
			{
				list[num + 1].opcode = OpCodes.Nop;
				list[num + 1].operand = null;
				list[num + 2].opcode = OpCodes.Nop;
				list[num + 2].operand = null;
				list[num + 3].opcode = OpCodes.Call;
				list[num + 3].operand = PatchesUtil.IsPlayerLocalOrLethalBotOwnerLocalMethod;
				num = -1;
			}
			else
			{
				Plugin.LogError("LethalBot.Patches.EnemiesPatches.CaveDwellerAIPatch.KillPlayerAnimationClientRpc_Transpiler could not check if local player or bot");
			}
			return list.AsEnumerable();
		}

		[HarmonyPatch("StartTransformationAnim")]
		[HarmonyPostfix]
		private static void StartTransformationAnim_PostFix(CaveDwellerAI __instance)
		{
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)((GrabbableObject)__instance.propScript).playerHeldBy == (Object)null))
			{
				LethalBotAI lethalBotAI = LethalBotManager.Instance.GetLethalBotAI(((GrabbableObject)__instance.propScript).playerHeldBy);
				if (!((Object)(object)lethalBotAI == (Object)null))
				{
					lethalBotAI.DropItem();
				}
			}
		}
	}
	[HarmonyPatch(typeof(CentipedeAI))]
	public class CentipedeAIPatch
	{
		[HarmonyPatch("Update")]
		[HarmonyPostfix]
		private static void Update_PostFix(ref CentipedeAI __instance)
		{
			if (!((EnemyAI)__instance).isEnemyDead)
			{
				int currentBehaviourStateIndex = ((EnemyAI)__instance).currentBehaviourStateIndex;
				if (currentBehaviourStateIndex == 3 && !((Object)(object)__instance.clingingToPlayer == (Object)null) && LethalBotManager.Instance.IsPlayerLethalBotOwnerLocal(__instance.clingingToPlayer))
				{
					DamagePlayerOnIntervals_ReversePatch(__instance);
				}
			}
		}

		[HarmonyPatch("DamagePlayerOnIntervals")]
		[HarmonyReversePatch(/*Could not decode attribute arguments.*/)]
		[HarmonyPriority(0)]
		public static void DamagePlayerOnIntervals_ReversePatch(object instance)
		{
			throw new NotImplementedException("Stub LethalBot.Patches.EnemiesPatches.DamagePlayerOnIntervals");
		}
	}
	[HarmonyPatch(typeof(CrawlerAI))]
	[HarmonyAfter(new string[] { "me.swipez.melonloader.morecompany" })]
	public class CrawlerAIPatch
	{
		[HarmonyPatch("OnCollideWithPlayer")]
		[HarmonyTranspiler]
		public static IEnumerable<CodeInstruction> OnCollideWithPlayer_Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator generator)
		{
			int num = -1;
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			for (int i = 0; i < list.Count - 5; i++)
			{
				if (((object)list[i]).ToString() == "ldarg.0 NULL" && ((object)list[i + 1]).ToString() == "call static GameNetworkManager GameNetworkManager::get_Instance()" && ((object)list[i + 2]).ToString() == "ldfld GameNetcodeStuff.PlayerControllerB GameNetworkManager::localPlayerController" && ((object)list[i + 5]).ToString() == "call void CrawlerAI::HitPlayerServerRpc(int playerId)")
				{
					num = i;
					break;
				}
			}
			if (num > -1)
			{
				list[num + 1].opcode = OpCodes.Nop;
				list[num + 1].operand = null;
				list[num + 2].opcode = OpCodes.Ldloc_0;
				list[num + 2].operand = null;
				num = -1;
			}
			else
			{
				Plugin.LogError("LethalBot.Patches.EnemiesPatches.CrawlerAIPatch.OnCollideWithPlayer_Transpiler could not change use of correct player id for HitPlayerServerRpc.");
			}
			for (int j = 0; j < list.Count - 4; j++)
			{
				if (((object)list[j]).ToString() == "call static GameNetworkManager GameNetworkManager::get_Instance()" && ((object)list[j + 1]).ToString() == "ldfld GameNetcodeStuff.PlayerControllerB GameNetworkManager::localPlayerController" && ((object)list[j + 4]).ToString() == "callvirt void GameNetcodeStuff.PlayerControllerB::JumpToFearLevel(float targetFearLevel, bool onlyGoUp)")
				{
					num = j;
					break;
				}
			}
			if (num > -1)
			{
				list[num].opcode = OpCodes.Nop;
				list[num].operand = null;
				list[num + 1].opcode = OpCodes.Ldloc_0;
				list[num + 1].operand = null;
				num = -1;
			}
			else
			{
				Plugin.LogError("LethalBot.Patches.EnemiesPatches.CrawlerAIPatch.OnCollideWithPlayer_Transpiler could not change use of correct player id for JumpToFearLevel.");
			}
			return list.AsEnumerable();
		}

		[HarmonyPatch("Update")]
		[HarmonyTranspiler]
		public static IEnumerable<CodeInstruction> Update_Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator generator)
		{
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Expected O, but got Unknown
			int num = -1;
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			for (int i = 0; i < list.Count - 3; i++)
			{
				if (((object)list[i]).ToString() == "ldloc.1 NULL [Label11]" && ((object)list[i + 2]).ToString() == "ldfld GameNetcodeStuff.PlayerControllerB GameNetworkManager::localPlayerController" && ((object)list[i + 3]).ToString() == "call static bool UnityEngine.Object::op_Equality(UnityEngine.Object x, UnityEngine.Object y)")
				{
					num = i;
					break;
				}
			}
			if (num > -1)
			{
				list[num + 1].opcode = OpCodes.Nop;
				list[num + 1].operand = null;
				list[num + 2] = new CodeInstruction(OpCodes.Call, (object)PatchesUtil.IsPlayerLocalOrLethalBotOwnerLocalMethod);
				list[num + 3].opcode = OpCodes.Nop;
				list[num + 3].operand = null;
				num = -1;
			}
			else
			{
				Plugin.LogError("LethalBot.Patches.EnemiesPatches.CrawlerAIPatch.Update_Transpiler could not change condition for is only local player.");
			}
			for (int j = 0; j < list.Count - 4; j++)
			{
				if (((object)list[j]).ToString() == "call static GameNetworkManager GameNetworkManager::get_Instance()" && ((object)list[j + 4]).ToString() == "call void CrawlerAI::BeginChasingPlayerServerRpc(int playerObjectId)")
				{
					num = j;
					break;
				}
			}
			if (num > -1)
			{
				list[num].opcode = OpCodes.Nop;
				list[num].operand = null;
				list[num + 1].opcode = OpCodes.Ldloc_1;
				list[num + 1].operand = null;
				num = -1;
			}
			else
			{
				Plugin.LogError("LethalBot.Patches.EnemiesPatches.CrawlerAIPatch.Update_Transpiler could not change target of begin chasing player.");
			}
			return list.AsEnumerable();
		}

		[HarmonyPatch("Update")]
		[HarmonyPostfix]
		public static void Update_Postfix(CrawlerAI __instance)
		{
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			if (((EnemyAI)__instance).isEnemyDead)
			{
				return;
			}
			UpdateLimiter orCreateMonitor = UpdateLimiter.GetOrCreateMonitor((EnemyAI)(object)__instance);
			if (!orCreateMonitor.CanUpdate())
			{
				return;
			}
			orCreateMonitor.Invalidate();
			LethalBotAI[] lethalBotsAIOwnedByLocal = LethalBotManager.Instance.GetLethalBotsAIOwnedByLocal();
			LethalBotAI[] array = lethalBotsAIOwnedByLocal;
			for (int i = 0; i < array.Length; i++)
			{
				PlayerControllerB val = array[i]?.NpcController?.Npc;
				if ((Object)(object)val != (Object)null && val.HasLineOfSightToPosition(((Component)__instance).transform.position + Vector3.up * 0.25f, 80f, 25, 5f, -1))
				{
					if (((EnemyAI)__instance).currentBehaviourStateIndex == 1)
					{
						val.IncreaseFearLevelOverTime(0.8f, 1f);
					}
					else
					{
						val.IncreaseFearLevelOverTime(0.8f, 0.5f);
					}
				}
			}
		}

		[HarmonyPatch("MakeScreech")]
		[HarmonyPostfix]
		public static void MakeScreech_Postfix(CrawlerAI __instance)
		{
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			LethalBotAI[] lethalBotsAIOwnedByLocal = LethalBotManager.Instance.GetLethalBotsAIOwnedByLocal();
			LethalBotAI[] array = lethalBotsAIOwnedByLocal;
			for (int i = 0; i < array.Length; i++)
			{
				PlayerControllerB val = array[i]?.NpcController?.Npc;
				if ((Object)(object)val != (Object)null)
				{
					Vector3 val2 = ((Component)val).transform.position - ((Component)__instance).transform.position;
					if (((Vector3)(ref val2)).sqrMagnitude < 225f)
					{
						val.JumpToFearLevel(0.75f, true);
					}
				}
			}
		}
	}
	[HarmonyPatch(typeof(DressGirlAI))]
	public class DressGirlAIPatch
	{
		[HarmonyPatch("ChoosePlayerToHaunt")]
		[HarmonyPostfix]
		public static void ChoosePlayerToHaunt_Postfix(ref int ___timesSeenByPlayer, ref int ___timesStared)
		{
			___timesSeenByPlayer = 0;
			___timesStared = 0;
		}

		[HarmonyPatch("Update")]
		[HarmonyTranspiler]
		public static IEnumerable<CodeInstruction> Update_Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator generator)
		{
			//IL_0192: Unknown result type (might be due to invalid IL or missing references)
			//IL_019e: Expected O, but got Unknown
			//IL_01ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b5: Expected O, but got Unknown
			//IL_01c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ca: Expected O, but got Unknown
			//IL_01d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e1: Expected O, but got Unknown
			//IL_0344: Unknown result type (might be due to invalid IL or missing references)
			//IL_034b: Expected O, but got Unknown
			//IL_0371: Unknown result type (might be due to invalid IL or missing references)
			//IL_037b: Expected O, but got Unknown
			//IL_0383: Unknown result type (might be due to invalid IL or missing references)
			//IL_038d: Expected O, but got Unknown
			//IL_0398: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a2: Expected O, but got Unknown
			//IL_03af: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b9: 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(DressGirlAI), "hauntingPlayer");
			FieldInfo fieldInfo3 = AccessTools.Field(typeof(DressGirlAI), "heartbeatMusic");
			MethodInfo methodInfo2 = AccessTools.Method(typeof(Object), "op_Inequality", (Type[])null, (Type[])null);
			MethodInfo methodInfo3 = AccessTools.Method(typeof(Mathf), "Lerp", (Type[])null, (Type[])null);
			MethodInfo methodInfo4 = AccessTools.PropertyGetter(typeof(SoundManager), "Instance");
			MethodInfo methodInfo5 = AccessTools.Method(typeof(SoundManager), "SetDiageticMixerSnapshot", (Type[])null, (Type[])null);
			MethodInfo methodInfo6 = AccessTools.PropertySetter(typeof(AudioSource), "volume");
			for (int i = 0; i < list.Count - 4; i++)
			{
				if (CodeInstructionExtensions.Calls(list[i], methodInfo) && CodeInstructionExtensions.LoadsField(list[i + 1], fieldInfo, false) && CodeInstructionExtensions.IsLdarg(list[i + 2], (int?)0) && CodeInstructionExtensions.LoadsField(list[i + 3], fieldInfo2, false) && CodeInstructionExtensions.Calls(list[i + 4], methodInfo2))
				{
					num = i;
					break;
				}
			}
			if (num > -1)
			{
				CodeInstruction val = list[num + 5];
				Label label = (Label)val.operand;
				List<Label> list2 = CodeInstructionExtensions.ExtractLabels(list[num]);
				list.RemoveRange(num, 6);
				List<CodeInstruction> collection = new List<CodeInstruction>
				{
					CodeInstructionExtensions.WithLabels(new CodeInstruction(OpCodes.Ldarg_0, (object)null), (IEnumerable<Label>)list2),
					new CodeInstruction(OpCodes.Ldfld, (object)fieldInfo2),
					new CodeInstruction(OpCodes.Call, (object)PatchesUtil.IsPlayerLocalOrLethalBotOwnerLocalMethod),
					new CodeInstruction(OpCodes.Brtrue, (object)label)
				};
				list.InsertRange(num, collection);
				num = -1;
			}
			else
			{
				Plugin.LogError("LethalBot.Patches.EnemiesPatches.DressGirlAIPatch.Update_Transpiler could not check if player local or bot local 1");
			}
			for (int j = 0; j < list.Count - 13; j++)
			{
				if (CodeInstructionExtensions.Calls(list[j], methodInfo4) && list[j + 1].opcode == OpCodes.Ldc_I4_1 && list[j + 2].opcode == OpCodes.Ldc_R4 && list[j + 2].operand is float num2 && num2 == 1f && CodeInstructionExtensions.Calls(list[j + 3], methodInfo5) && CodeInstructionExtensions.IsLdarg(list[j + 4], (int?)0) && CodeInstructionExtensions.LoadsField(list[j + 5], fieldInfo3, false) && CodeInstructionExtensions.Calls(list[j + 13], methodInfo3))
				{
					num = j;
					break;
				}
			}
			if (num > -1)
			{
				int num3 = -1;
				for (int k = num; k < list.Count; k++)
				{
					if (CodeInstructionExtensions.Calls(list[k], methodInfo6))
					{
						num3 = k;
						break;
					}
				}
				if (num3 == -1)
				{
					Plugin.LogError("Could not find heartbeat volume store!");
					num3 = num + 14;
				}
				Label label2 = generator.DefineLabel();
				CodeInstruction val2 = new CodeInstruction(OpCodes.Nop, (object)null);
				val2.labels.Add(label2);
				list.Insert(num3 + 1, val2);
				List<CodeInstruction> collection2 = new List<CodeInstruction>
				{
					new CodeInstruction(OpCodes.Ldarg_0, (object)null),
					new CodeInstruction(OpCodes.Ldfld, (object)fieldInfo2),
					new CodeInstruction(OpCodes.Call, (object)PatchesUtil.IsPlayerLocalMethod),
					new CodeInstruction(OpCodes.Brfalse, (object)label2)
				};
				list.InsertRange(num, collection2);
			}
			else
			{
				Plugin.LogError("LethalBot.Patches.EnemiesPatches.DressGirlAIPatch.Update_Transpiler could not find and replace sound blur check!");
			}
			return list.AsEnumerable();
		}

		[HarmonyPatch("Update")]
		[HarmonyPostfix]
		public static void Update_Postfix(DressGirlAI __instance, ref bool ___enemyMeshEnabled)
		{
			if (((NetworkBehaviour)__instance).IsOwner && (Object)(object)__instance.hauntingPlayer != (Object)(object)GameNetworkManager.Instance.localPlayerController)
			{
				if (___enemyMeshEnabled)
				{
					___enemyMeshEnabled = false;
					((EnemyAI)__instance).EnableEnemyMesh(false, true, false);
				}
				__instance.SFXVolumeLerpTo = 0f;
				((EnemyAI)__instance).creatureVoice.Stop();
				__instance.heartbeatMusic.volume = 0f;
				((EnemyAI)__instance).creatureSFX.volume = 0f;
				if (!__instance.hauntingLocalPlayer && LethalBotManager.Instance.IsPlayerLocalOrLethalBotOwnerLocal(__instance.hauntingPlayer))
				{
					__instance.hauntingLocalPlayer = true;
				}
				else if (__instance.hauntingLocalPlayer && !LethalBotManager.Instance.IsPlayerLocalOrLethalBotOwnerLocal(__instance.hauntingPlayer))
				{
					__instance.hauntingLocalPlayer = false;
				}
			}
		}

		[HarmonyPatch("SetHauntStarePosition")]
		[HarmonyPostfix]
		public static void SetHauntStarePosition_Postfix(DressGirlAI __instance, ref bool ___enemyMeshEnabled)
		{
			if ((Object)(object)__instance.hauntingPlayer != (Object)(object)GameNetworkManager.Instance.localPlayerController)
			{
				if (___enemyMeshEnabled)
				{
					___enemyMeshEnabled = false;
					((EnemyAI)__instance).EnableEnemyMesh(false, true, false);
				}
				__instance.SFXVolumeLerpTo = 0f;
				((EnemyAI)__instance).creatureSFX.volume = 0f;
				((EnemyAI)__instance).creatureVoice.Stop();
			}
		}

		[HarmonyPatch("SetHauntStarePosition")]
		[HarmonyTranspiler]
		public static IEnumerable<CodeInstruction> SetHauntStarePosition_Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator generator)
		{
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0109: Expected O, but got Unknown
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			//IL_011a: Expected O, but got Unknown
			//IL_0125: Unknown result type (might be due to invalid IL or missing references)
			//IL_012f: Expected O, but got Unknown
			//IL_013c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0146: Expected O, but got Unknown
			//IL_016c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0173: Expected O, but got Unknown
			int num = -1;
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			FieldInfo fieldInfo = AccessTools.Field(typeof(DressGirlAI), "hauntingPlayer");
			FieldInfo fieldInfo2 = AccessTools.Field(typeof(DressGirlAI), "SFXVolumeLerpTo");
			MethodInfo playMethod = AccessTools.Method(typeof(AudioSource), "Play", (Type[])null, (Type[])null);
			for (int i = 0; i < list.Count - 2; i++)
			{
				if (CodeInstructionExtensions.IsLdarg(list[i], (int?)0) && list[i + 1].opcode == OpCodes.Ldc_R4 && list[i + 1].operand is float num2 && num2 == 1f && CodeInstructionExtensions.StoresField(list[i + 2], fieldInfo2))
				{
					num = i;
					break;
				}
			}
			if (num > -1)
			{
				Label label = generator.DefineLabel();
				List<CodeInstruction> collection = new List<CodeInstruction>
				{
					new CodeInstruction(OpCodes.Ldarg_0, (object)null),
					new CodeInstruction(OpCodes.Ldfld, (object)fieldInfo),
					new CodeInstruction(OpCodes.Call, (object)PatchesUtil.IsPlayerLocalMethod),
					new CodeInstruction(OpCodes.Brfalse, (object)label)
				};
				list.InsertRange(num, collection);
				int num3 = list.FindIndex(num, (CodeInstruction ci) => CodeInstructionExtensions.Calls(ci, playMethod));
				CodeInstruction val = new CodeInstruction(OpCodes.Nop, (object)null);
				val.labels.Add(label);
				list.Insert(num3 + 1, val);
				num = -1;
			}
			else
			{
				Plugin.LogError("LethalBot.Patches.EnemiesPatches.DressGirlAIPatch.SetHauntStarePosition_Transpiler could not check if player local or bot local 1");
			}
			return list.AsEnumerable();
		}
	}
	[HarmonyPatch(typeof(FlowermanAI))]
	public class FlowermanAIPatch
	{
		[HarmonyPatch("Update")]
		[HarmonyPostfix]
		public static void Update_Postfix(FlowermanAI __instance)
		{
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			if (((EnemyAI)__instance).isEnemyDead || __instance.inKillAnimation || (Object)(object)GameNetworkManager.Instance == (Object)null)
			{
				return;
			}
			UpdateLimiter orCreateMonitor = UpdateLimiter.GetOrCreateMonitor((EnemyAI)(object)__instance);
			if (!orCreateMonitor.CanUpdate())
			{
				return;
			}
			orCreateMonitor.Invalidate();
			LethalBotAI[] lethalBotsAIOwnedByLocal = LethalBotManager.Instance.GetLethalBotsAIOwnedByLocal();
			LethalBotAI[] array = lethalBotsAIOwnedByLocal;
			for (int i = 0; i < array.Length; i++)
			{
				PlayerControllerB val = array[i]?.NpcController?.Npc;
				if (!((Object)(object)val != (Object)null) || !val.HasLineOfSightToPosition(((Component)__instance).transform.position + Vector3.up * 0.5f, 30f, 60, -1f, -1))
				{
					continue;
				}
				if (((EnemyAI)__instance).currentBehaviourStateIndex == 0)
				{
					((EnemyAI)__instance).SwitchToBehaviourState(1);
					if (!((EnemyAI)__instance).thisNetworkObject.IsOwner)
					{
						((EnemyAI)__instance).ChangeOwnershipOfEnemy(val.actualClientId);
					}
					if (Vector3.Distance(((Component)__instance).transform.position, ((Component)val).transform.position) < 5f)
					{
						val.JumpToFearLevel(0.6f, true);
					}
					else
					{
						val.JumpToFearLevel(0.3f, true);
					}
					((EnemyAI)__instance).agent.speed = 0f;
					__instance.evadeStealthTimer = 0f;
				}
				else if (__instance.evadeStealthTimer > 0.5f)
				{
					int num = (int)val.playerClientId;
					__instance.LookAtFlowermanTrigger(num);
					__instance.ResetFlowermanStealthTimerServerRpc(num);
				}
			}
		}

		[HarmonyPatch("KillPlayerAnimationClientRpc")]
		[HarmonyTranspiler]
		public static IEnumerable<CodeInstruction> KillPlayerAnimationClientRpc_Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator generator)
		{
			int num = -1;
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			for (int i = 0; i < list.Count - 2; i++)
			{
				if (((object)list[i]).ToString() == "call static GameNetworkManager GameNetworkManager::get_Instance()" && ((object)list[i + 1]).ToString() == "ldfld GameNetcodeStuff.PlayerControllerB GameNetworkManager::localPlayerController" && ((object)list[i + 2]).ToString() == "call static bool UnityEngine.Object::op_Equality(UnityEngine.Object x, UnityEngine.Object y)")
				{
					num = i;
					break;
				}
			}
			if (num > -1)
			{
				list[num].opcode = OpCodes.Nop;
				list[num].operand = null;
				list[num + 1].opcode = OpCodes.Nop;
				list[num + 1].operand = null;
				list[num + 2].opcode = OpCodes.Call;
				list[num + 2].operand = PatchesUtil.IsPlayerLocalOrLethalBotOwnerLocalMethod;
				num = -1;
			}
			else
			{
				Plugin.LogError("LethalBot.Patches.EnemiesPatches.FlowermanAIPatch.KillPlayerAnimationClientRpc_Transpiler could not check if player local or bot local 1");
			}
			return list.AsEnumerable();
		}
	}
	[HarmonyPatch(typeof(FlowerSnakeEnemy))]
	public class FlowerSnakeEnemyPatch
	{
		[HarmonyPatch("OnCollideWithPlayer")]
		[HarmonyTranspiler]
		public static IEnumerable<CodeInstruction> OnCollideWithPlayer_Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator generator)
		{
			int num = -1;
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			for (int i = 0; i < list.Count - 4; i++)
			{
				if (((object)list[i]).ToString() == "call static GameNetworkManager GameNetworkManager::get_Instance()" && ((object)list[i + 1]).ToString() == "ldfld GameNetcodeStuff.PlayerControllerB GameNetworkManager::localPlayerController" && ((object)list[i + 4]).ToString() == "call void FlowerSnakeEnemy::FSHitPlayerServerRpc(int playerId)")
				{
					num = i;
					break;
				}
			}
			if (num > -1)
			{
				list[num].opcode = OpCodes.Nop;
				list[num].operand = null;
				list[num + 1].opcode = OpCodes.Ldloc_0;
				list[num + 1].operand = null;
				num = -1;
			}
			else
			{
				Plugin.LogError("LethalBot.Patches.EnemiesPatches.FlowerSnakeEnemyPatch.OnCollideWithPlayer_Transpiler could not use id player local or bot");
			}
			return list.AsEnumerable();
		}

		[HarmonyPatch("MainSnakeActAsConductor")]
		[HarmonyPostfix]
		private static void MainSnakeActAsConductor_PostFix(FlowerSnakeEnemy __instance, ref Vector3 ___forces)
		{
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: Unknown result type (might be due to invalid IL or missing references)
			//IL_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0135: Unknown result type (might be due to invalid IL or missing references)
			//IL_013a: Unknown result type (might be due to invalid IL or missing references)
			//IL_015e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0164: Unknown result type (might be due to invalid IL or missing references)
			//IL_0169: Unknown result type (might be due to invalid IL or missing references)
			//IL_016e: Unknown result type (might be due to invalid IL or missing references)
			//IL_014d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0152: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)__instance.clingingToPlayer == (Object)null)
			{
				return;
			}
			LethalBotAI lethalBotAI = LethalBotManager.Instance.GetLethalBotAI(__instance.clingingToPlayer);
			if ((Object)(object)lethalBotAI == (Object)null)
			{
				return;
			}
			if ((__instance.clingingToPlayer.isInElevator && StartOfRound.Instance.shipIsLeaving) || (Object)(object)__instance.clingingToPlayer.inAnimationWithEnemy != (Object)null || __instance.clingToPlayerTimer <= 0f || ((EnemyAI)__instance).daytimeEnemyLeaving)
			{
				int num = (int)__instance.clingingToPlayer.playerClientId;
				__instance.StopClingingOnLocalClient(true);
				__instance.StopClingingServerRpc(num);
				return;
			}
			if (__instance.activatedFlight)
			{
				__instance.flightPower = Mathf.Clamp(__instance.flightPower + Time.deltaTime * 1.7f, 12f, (float)__instance.clingingToPlayer.enemiesOnPerson * 4f);
			}
			else
			{
				__instance.flightPower = Mathf.Clamp(__instance.flightPower - Time.deltaTime * 50f, 0f, 1000f);
				if (lethalBotAI.NpcController.IsTouchingGround)
				{
					__instance.flightPower = 0f;
				}
			}
			___forces = Vector3.Lerp(___forces, Vector3.ClampMagnitude(((Component)__instance.clingingToPlayer).transform.up * __instance.flightPower, 400f), Time.deltaTime);
			if (!__instance.clingingToPlayer.jetpackControls)
			{
				___forces = Vector3.zero;
			}
			PlayerControllerB clingingToPlayer = __instance.clingingToPlayer;
			clingingToPlayer.externalForces += ___forces;
		}

		[HarmonyPatch("FSHitPlayerServerRpc")]
		[HarmonyPostfix]
		private static void FSHitPlayerServerRpc_PostFix(ref bool ___waitingForHitPlayerRPC, int playerId)
		{
			if (LethalBotManager.Instance.IsIdPlayerLethalBotOwnerLocal(playerId) & ___waitingForHitPlayerRPC)
			{
				___waitingForHitPlayerRPC = false;
			}
		}

		[HarmonyPatch("ClingToPlayerClientRpc")]
		[HarmonyPostfix]
		private static void ClingToPlayerClientRpc_PostFix(ref bool ___waitingForHitPlayerRPC, int playerId)
		{
			if (LethalBotManager.Instance.IsIdPlayerLethalBotOwnerLocal(playerId) & ___waitingForHitPlayerRPC)
			{
				___waitingForHitPlayerRPC = false;
			}
		}
	}
	[HarmonyPatch(typeof(ForestGiantAI))]
	public class ForestGiantAIPatch
	{
		[HarmonyPatch("GiantSeePlayerEffect")]
		[HarmonyPostfix]
		public static void GiantSeePlayerEffect_Postfix(ForestGiantAI __instance, ref bool ___lostPlayerInChase)
		{
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			LethalBotAI[] lethalBotsAIOwnedByLocal = LethalBotManager.Instance.GetLethalBotsAIOwnedByLocal();
			LethalBotAI[] array = lethalBotsAIOwnedByLocal;
			for (int i = 0; i < array.Length; i++)
			{
				PlayerControllerB val = array[i]?.NpcController.Npc;
				if (!((Object)(object)val != (Object)null) || val.isPlayerDead || val.isInsideFactory)
				{
					continue;
				}
				if (((EnemyAI)__instance).currentBehaviourStateIndex == 1 && (Object)(object)__instance.chasingPlayer == (Object)(object)val && !___lostPlayerInChase)
				{
					val.IncreaseFearLevelOverTime(1.4f, 1f);
				}
				else if (!val.isInHangarShipRoom && ((EnemyAI)__instance).CheckLineOfSightForPosition(((Component)val.gameplayCamera).transform.position, 45f, 70, -1f, (Transform)null))
				{
					if (Vector3.Distance(((Component)__instance).transform.position, ((Component)val).transform.position) < 15f)
					{
						val.JumpToFearLevel(0.7f, true);
					}
					else
					{
						val.JumpToFearLevel(0.4f, true);
					}
				}
			}
		}

		[HarmonyPatch("OnCollideWithPlayer")]
		[HarmonyTranspiler]
		public static IEnumerable<CodeInstruction> OnCollideWithPlayer_Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator generator)
		{
			int num = -1;
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			for (int i = 0; i < list.Count - 2; i++)
			{
				if (((object)list[i]).ToString() == "call static GameNetworkManager GameNetworkManager::get_Instance()" && ((object)list[i + 1]).ToString() == "ldfld GameNetcodeStuff.PlayerControllerB GameNetworkManager::localPlayerController" && ((object)list[i + 2]).ToString() == "call static bool UnityEngine.Object::op_Equality(UnityEngine.Object x, UnityEngine.Object y)")
				{
					num = i;
					break;
				}
			}
			if (num > -1)
			{
				list[num].opcode = OpCodes.Nop;
				list[num].operand = null;
				list[num + 1].opcode = OpCodes.Nop;
				list[num + 1].operand = null;
				list[num + 2].opcode = OpCodes.Call;
				list[num + 2].operand = PatchesUtil.IsPlayerLocalOrLethalBotOwnerLocalMethod;
				num = -1;
			}
			else
			{
				Plugin.LogError("LethalBot.Patches.EnemiesPatches.ForestGiantAIPatch.OnCollideWithPlayer_Transpiler could not check if player local or bot");
			}
			for (int j = 0; j < list.Count - 1; j++)
			{
				if (((object)list[j]).ToString() == "call static GameNetworkManager GameNetworkManager::get_Instance()" && ((object)list[j + 1]).ToString() == "ldfld GameNetcodeStuff.PlayerControllerB GameNetworkManager::localPlayerController")
				{
					list[j].opcode = OpCodes.Nop;
					list[j].operand = null;
					list[j + 1].opcode = OpCodes.Ldloc_0;
					list[j + 1].operand = null;
				}
			}
			return list.AsEnumerable();
		}

		[HarmonyPatch("AnimationEventA")]
		[HarmonyTranspiler]
		public static IEnumerable<CodeInstruction> AnimationEventA_Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator generator)
		{
			int num = -1;
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			for (int i = 0; i < list.Count - 2; i++)
			{
				if (((object)list[i]).ToString() == "call static GameNetworkManager GameNetworkManager::get_Instance()" && ((object)list[i + 1]).ToString() == "ldfld GameNetcodeStuff.PlayerControllerB GameNetworkManager::localPlayerController" && ((object)list[i + 2]).ToString() == "call static bool UnityEngine.Object::op_Equality(UnityEngine.Object x, UnityEngine.Object y)")
				{
					num = i;
					break;
				}
			}
			if (num > -1)
			{
				list[num].opcode = OpCodes.Nop;
				list[num].operand = null;
				list[num + 1].opcode = OpCodes.Nop;
				list[num + 1].operand = null;
				list[num + 2].opcode = OpCodes.Call;
				list[num + 2].operand = PatchesUtil.IsPlayerLocalOrLethalBotOwnerLocalMethod;
				num = -1;
			}
			else
			{
				Plugin.LogError("LethalBot.Patches.EnemiesPatches.ForestGiantAIPatch.AnimationEventA_Transpiler could not check if player local or bot");
			}
			for (int j = 0; j < list.Count - 1; j++)
			{
				if (((object)list[j]).ToString() == "call static GameNetworkManager GameNetworkManager::get_Instance()" && ((object)list[j + 1]).ToString() == "ldfld GameNetcodeStuff.PlayerControllerB GameNetworkManager::localPlayerController")
				{
					Plugin.LogDebug($"Replaced GameNetworkManagerInstance at {j} in ForestGiantAI AnimationEventA with component!");
					list[j].opcode = OpCodes.Nop;
					list[j].operand = null;
					list[j + 1].opcode = OpCodes.Ldloc_0;
					list[j + 1].operand = null;
				}
			}
			return list.AsEnumerable();
		}
	}
	[HarmonyPatch(typeof(GiantKiwiAI))]
	public class GiantKiwiAIPatch
	{
		private class GiantKiwiPlayerMonitor
		{
			public Dictionary<LethalBotAI, float> lethalBotAIs = new Dictionary<LethalBotAI, float>();

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			public void UpdateTimeSinceHittingBot(LethalBotAI bot)
			{
				lethalBotAIs[bot] = Time.timeSinceLevelLoad;
			}

			public bool ShouldApplyDamageTo(LethalBotAI bot)
			{
				float valueOrDefault = lethalBotAIs.GetValueOrDefault(bot);
				return Time.timeSinceLevelLoad - valueOrDefault < 0.1f;
			}
		}

		private static ConditionalWeakTable<GiantKiwiAI, GiantKiwiPlayerMonitor> lethalBotGiantKiwiMonitor = new ConditionalWeakTable<GiantKiwiAI, GiantKiwiPlayerMonitor>();

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static GiantKiwiPlayerMonitor GetOrCreateMonitor(GiantKiwiAI ai)
		{
			return lethalBotGiantKiwiMonitor.GetOrCreateValue(ai);
		}

		[HarmonyPatch("OnCollideWithPlayer")]
		[HarmonyPrefix]
		public static bool OnCollideWithPlayer_Prefix(GiantKiwiAI __instance, Collider other, ref bool ___attacking)
		{
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: 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)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			PlayerControllerB val = ((EnemyAI)__instance).MeetsStandardPlayerCollisionConditions(other, __instance.inKillAnimation, false);
			LethalBotAI lethalBotAIIfLocalIsOwner = LethalBotManager.Instance.GetLethalBotAIIfLocalIsOwner(val);
			if ((Object)(object)lethalBotAIIfLocalIsOwner == (Object)null)
			{
				return true;
			}
			if (!val.isInHangarShipRoom || ((EnemyAI)__instance).isInsidePlayerShip || !(((Component)val).transform.position.y - ((Component)__instance).transform.position.y > 1.6f) || !Physics.Linecast(((Component)__instance).transform.position + Vector3.up * 0.45f, ((Component)val).transform.position + Vector3.up * 0.45f, StartOfRound.Instance.collidersAndRoomMaskAndDefault, (QueryTriggerInteraction)1))
			{
				GiantKiwiPlayerMonitor orCreateMonitor = GetOrCreateMonitor(__instance);
				orCreateMonitor.UpdateTimeSinceHittingBot(lethalBotAIIfLocalIsOwner);
				if (___attacking)
				{
					val.JumpToFearLevel(1f, true);
				}
			}
			return false;
		}

		[HarmonyPatch("AnimationEventB")]
		[HarmonyPostfix]
		public static void AnimationEventB_Postfix(GiantKiwiAI __instance, ref bool ___attacking)
		{
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: 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)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			if (!___attacking || ((EnemyAI)__instance).isEnemyDead)
			{
				return;
			}
			GiantKiwiPlayerMonitor orCreateMonitor = GetOrCreateMonitor(__instance);
			List<LethalBotAI> list = new List<LethalBotAI>(orCreateMonitor.lethalBotAIs.Keys);
			foreach (LethalBotAI item in list)
			{
				if ((Object)(object)item != (Object)null && orCreateMonitor.ShouldApplyDamageTo(item))
				{
					PlayerControllerB npc = item.NpcController.Npc;
					_ = ((Component)npc).transform.position;
					Vector3 val = ((Component)npc).transform.position + Vector3.up * 3f - ((Component)__instance).transform.position;
					npc.externalForceAutoFade += val * __instance.hitVelocityForce;
					npc.DamagePlayer(10, true, true, (CauseOfDeath)14, 9, false, val * __instance.hitVelocityForce * 0.4f);
					orCreateMonitor.UpdateTimeSinceHittingBot(item);
				}
			}
		}

		[HarmonyPatch("OnDestroy")]
		[HarmonyPostfix]
		private static void OnDestroy_Postfix(GiantKiwiAI __instance)
		{
			if (lethalBotGiantKiwiMonitor.TryGetValue(__instance, out GiantKiwiPlayerMonitor _))
			{
				lethalBotGiantKiwiMonitor.Remove(__instance);
			}
		}
	}
	[HarmonyPatch(typeof(JesterAI))]
	public class JesterAIPatch
	{
		[HarmonyPatch("KillPlayerServerRpc")]
		[HarmonyTranspiler]
		public static IEnumerable<CodeInstruction> KillPlayerServerRpc_Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator generator)
		{
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Expected O, but got Unknown
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: 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
			int num = -1;
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			for (int i = 0; i < list.Count - 1; i++)
			{
				if (((object)list[i]).ToString().StartsWith("ldfld bool JesterAI::inKillAnimation") && ((object)list[i + 1]).ToString().StartsWith("brfalse"))
				{
					num = i;
					break;
				}
			}
			if (num > -1)
			{
				List<CodeInstruction> collection = new List<CodeInstruction>
				{
					new CodeInstruction(OpCodes.Ldarg_1, (object)null),
					new CodeInstruction(OpCodes.Call, (object)PatchesUtil.IsIdPlayerLethalBotMethod),
					new CodeInstruction(OpCodes.Brtrue, (object)list[num + 8].labels.First())
				};
				list.InsertRange(num + 2, collection);
				num = -1;
			}
			else
			{
				Plugin.LogError("LethalBot.Patches.EnemiesPatches.JesterAIPatch.KillPlayerServerRpc_Transpiler could not call check if bot.");
			}
			return list.AsEnumerable();
		}
	}
	[HarmonyPatch(typeof(MaskedPlayerEnemy))]
	public class MaskedPlayerEnemyPatch
	{
		[HarmonyPatch("FinishKillAnimation")]
		[HarmonyPrefix]
		private static bool FinishKillAnimation_PreFix(MaskedPlayerEnemy __instance)
		{
			if ((Object)(object)((EnemyAI)__instance).inSpecialAnimationWithPlayer == (Object)null)
			{
				return true;
			}
			LethalBotAI lethalBotAI = LethalBotManager.Instance.GetLethalBotAI(((EnemyAI)__instance).inSpecialAnimationWithPlayer);
			if ((Object)(object)lethalBotAI == (Object)null)
			{
				return true;
			}
			if ((Object)(object)lethalBotAI.NpcController.EnemyInAnimationWith == (Object)(object)__instance)
			{
				lethalBotAI.NpcController.EnemyInAnimationWith = null;
			}
			return true;
		}

		[HarmonyPatch("KillPlayerAnimationClientRpc")]
		[HarmonyTranspiler]
		public static IEnumerable<CodeInstruction> KillPlayerAnimationClientRpc_Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator generator)
		{
			int num = -1;
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			for (int i = 0; i < list.Count - 2; i++)
			{
				if (((object)list[i]).ToString() == "call static GameNetworkManager GameNetworkManager::get_Instance()" && ((object)list[i + 1]).ToString() == "ldfld GameNetcodeStuff.PlayerControllerB GameNetworkManager::localPlayerController" && ((object)list[i + 2]).ToString() == "call static bool UnityEngine.Object::op_Equality(UnityEngine.Object x, UnityEngine.Object y)")
				{
					num = i;
					break;
				}
			}
			if (num > -1)
			{
				list[num].opcode = OpCodes.Nop;
				list[num].operand = null;
				list[num + 1].opcode = OpCodes.Nop;
				list[num + 1].operand = null;
				list[num + 2].opcode = OpCodes.Call;
				list[num + 2].operand = PatchesUtil.IsPlayerLocalOrLethalBotOwnerLocalMethod;
				num = -1;
			}
			else
			{
				Plugin.LogError("LethalBot.Patches.EnemiesPatches.MaskedPlayerEnemyPatch.KillPlayerAnimationClientRpc_Transpiler could not check if player local or bot local 1");
			}
			for (int j = 0; j < list.Count - 2; j++)
			{
				if (((object)list[j]).ToString() == "call static GameNetworkManager GameNetworkManager::get_Instance()" && ((object)list[j + 1]).ToString() == "ldfld GameNetcodeStuff.PlayerControllerB GameNetworkManager::localPlayerController" && ((object)list[j + 2]).ToString() == "call static bool UnityEngine.Object::op_Equality(UnityEngine.Object x, UnityEngine.Object y)")
				{
					num = j;
					break;
				}
			}
			if (num > -1)
			{
				list[num].opcode = OpCodes.Nop;
				list[num].operand = null;
				list[num + 1].opcode = OpCodes.Nop;
				list[num + 1].operand = null;
				list[num + 2].opcode = OpCodes.Call;
				list[num + 2].operand = PatchesUtil.IsPlayerLocalOrLethalBotOwnerLocalMethod;
				num = -1;
			}
			else
			{
				Plugin.LogError("LethalBot.Patches.EnemiesPatches.MaskedPlayerEnemyPatch.KillPlayerAnimationClientRpc_Transpiler could not check if player local or bot local 2");
			}
			return list.AsEnumerable();
		}

		[HarmonyPatch("KillPlayerAnimationClientRpc")]
		[HarmonyPostfix]
		private static void KillPlayerAnimationClientRpc_PostFix(MaskedPlayerEnemy __instance)
		{
			if (!((Object)(object)((EnemyAI)__instance).inSpecialAnimationWithPlayer == (Object)null))
			{
				LethalBotAI lethalBotAI = LethalBotManager.Instance.GetLethalBotAI(((EnemyAI)__instance).inSpecialAnimationWithPlayer);
				if (!((Object)(object)lethalBotAI == (Object)null))
				{
					lethalBotAI.NpcController.EnemyInAnimationWith = (EnemyAI?)(object)__instance;
				}
			}
		}
	}
	[HarmonyPatch(typeof(MouthDogAI))]
	public class MouthDogAIPatch
	{
		[HarmonyPatch("OnCollideWithEnemy")]
		[HarmonyPrefix]
		private static bool OnCollideWithEnemy_PreFix(Collider other, EnemyAI collidedEnemy)
		{
			if ((Object)(object)collidedEnemy == (Object)null)
			{
				return true;
			}
			if (LethalBotManager.Instance.IsAILethalBotAi(collidedEnemy))
			{
				return false;
			}
			return true;
		}

		[HarmonyPatch("KillPlayer")]
		[HarmonyPrefix]
		private static bool KillPlayer_PreFix(int playerId)
		{
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			LethalBotAI lethalBotAIIfLocalIsOwner = LethalBotManager.Instance.GetLethalBotAIIfLocalIsOwner(playerId);
			if ((Object)(object)lethalBotAIIfLocalIsOwner == (Object)null)
			{
				return true;
			}
			Plugin.LogDebug($"SyncKillLethalBot from mouthdogAI for LOCAL client #{((NetworkBehaviour)lethalBotAIIfLocalIsOwner).NetworkManager.LocalClientId}, lethalBot object: Bot #{lethalBotAIIfLocalIsOwner.BotId}");
			lethalBotAIIfLocalIsOwner.NpcController.Npc.KillPlayer(Vector3.zero, true, (CauseOfDeath)6, 0, default(Vector3), false);
			return true;
		}

		[HarmonyPatch("OnCollideWithPlayer")]
		[HarmonyPrefix]
		private static bool OnCollideWithPlayer_PreFix(ref MouthDogAI __instance, Collider other, bool ___inKillAnimation)
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			PlayerControllerB val = ((EnemyAI)__instance).MeetsStandardPlayerCollisionConditions(other, ___inKillAnimation, false);
			if ((Object)(object)val == (Object)null)
			{
				return false;
			}
			LethalBotAI lethalBotAIIfLocalIsOwner = LethalBotManager.Instance.GetLethalBotAIIfLocalIsOwner(val);
			if ((Object)(object)lethalBotAIIfLocalIsOwner == (Object)null)
			{
				return true;
			}
			Vector3 val2 = Vector3.Normalize((((Component)__instance).transform.position + Vector3.up - ((Component)val.gameplayCamera).transform.position) * 100f);
			RaycastHit val3 = default(RaycastHit);
			if (!Physics.Linecast(((Component)__instance).transform.position + Vector3.up + val2 * 0.5f, ((Component)val.gameplayCamera).transform.position, ref val3, StartOfRound.Instance.collidersAndRoomMask, (QueryTriggerInteraction)1) && (((EnemyAI)__instance).currentBehaviourStateIndex == 0 || ((EnemyAI)__instance).currentBehaviourStateIndex == 1))
			{
				((EnemyAI)__instance).SwitchToBehaviourState(2);
				((EnemyAI)__instance).ChangeOwnershipOfEnemy(val.actualClientId);
				((EnemyAI)__instance).SetDestinationToPosition(((Component)val).transform.position, false);
				return false;
			}
			return true;
		}

		[HarmonyPatch("Update")]
		[HarmonyPostfix]
		private static void Update_PostFix(ref MouthDogAI __instance, bool ___inKillAnimation, bool ___inLunge, ref float ___lungeCooldown)
		{
			if (((EnemyAI)__instance).currentBehaviourStateIndex == 2 && __instance.endingLunge && ___inLunge && !___inKillAnimation)
			{
				___lungeCooldown = 0.25f;
				__instance.EndLungeServerRpc();
			}
		}
	}
	[HarmonyPatch(typeof(NutcrackerEnemyAI))]
	public class NutcrackerEnemyAIPatch
	{
		[HarmonyPatch("Update")]
		[HarmonyPostfix]
		private static void Update_Postfix(NutcrackerEnemyAI __instance, ref bool ___isInspecting, ref float ___timeSinceSeeingTarget, ref float ___timeSinceFiringGun, ref bool ___reloadingGun, ref bool ___aimingGun, ref float ___timeSinceHittingPlayer, ref bool ___lostPlayerInChase, ref Vector3 ___lastSeenPlayerPos)
		{
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0145: Unknown result type (might be due to invalid IL or missing references)
			//IL_0156: Unknown result type (might be due to invalid IL or missing references)
			//IL_0166: Unknown result type (might be due to invalid IL or missing references)
			//IL_016b: Unknown result type (might be due to invalid IL or missing references)
			//IL_024d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0268: Unknown result type (might be due to invalid IL or missing references)
			//IL_026d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0272: Unknown result type (might be due to invalid IL or missing references)
			//IL_0283: Unknown result type (might be due to invalid IL or missing references)
			//IL_028f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0294: Unknown result type (might be due to invalid IL or missing references)
			//IL_0299: Unknown result type (might be due to invalid IL or missing references)
			//IL_019a: Unknown result type (might be due to invalid IL or missing references)
			if (((EnemyAI)__instance).isEnemyDead || ((EnemyAI)__instance).stunNormalizedTimer >= 0f)
			{
				return;
			}
			UpdateLimiter orCreateMonitor = UpdateLimiter.GetOrCreateMonitor((EnemyAI)(object)__instance);
			if (!orCreateMonitor.CanUpdate())
			{
				return;
			}
			orCreateMonitor.Invalidate();
			switch (((EnemyAI)__instance).currentBehaviourStateIndex)
			{
			case 1:
			{
				if (!___isInspecting)
				{
					break;
				}
				LethalBotAI[] lethalBotsAIOwnedByLocal2 = LethalBotManager.Instance.GetLethalBotsAIOwnedByLocal();
				LethalBotAI[] array2 = lethalBotsAIOwnedByLocal2;
				for (int j = 0; j < array2.Length; j++)
				{
					PlayerControllerB val4 = array2[j]?.NpcController?.Npc;
					if (IsPlayerMoving(val4) && CheckLineOfSightForPlayer(__instance, val4, 70f, 60, 1))
					{
						___isInspecting = false;
						__instance.SeeMovingThreatServerRpc((int)val4.playerClientId, false);
						break;
					}
				}
				break;
			}
			case 2:
			{
				if (__instance.lastPlayerSeenMoving == -1)
				{
					break;
				}
				PlayerControllerB val = StartOfRound.Instance.allPlayerScripts[__instance.lastPlayerSeenMoving];
				if (LethalBotManager.Instance.IsPlayerLethalBotOwnerLocal(val) && ((EnemyAI)__instance).CheckLineOfSightForPosition(((Component)val.gameplayCamera).transform.position, 70f, 60, 1f, (Transform)null) && ___timeSinceSeeingTarget < 8f)
				{
					if (___timeSinceFiringGun > 0.75f && !___reloadingGun && !___aimingGun && ___timeSinceHittingPlayer > 1f && Vector3.Angle(__instance.gun.shotgunRayPoint.forward, ((Component)val.gameplayCamera).transform.position - __instance.gun.shotgunRayPoint.position) < 30f)
					{
						___timeSinceFiringGun = 0f;
						((EnemyAI)__instance).agent.speed = 0f;
						__instance.AimGunServerRpc(((Component)__instance).transform.position);
					}
					if (___lostPlayerInChase)
					{
						___lostPlayerInChase = false;
						__instance.SetLostPlayerInChaseServerRpc(false);
					}
					___timeSinceSeeingTarget = 0f;
					___lastSeenPlayerPos = ((Component)val).transform.position;
				}
				LethalBotAI[] lethalBotsAIOwnedByLocal = LethalBotManager.Instance.GetLethalBotsAIOwnedByLocal();
				LethalBotAI[] array = lethalBotsAIOwnedByLocal;
				for (int i = 0; i < array.Length; i++)
				{
					PlayerControllerB val2 = array[i]?.NpcController?.Npc;
					if (IsPlayerMoving(val2) && CheckLineOfSightForPlayer(__instance, val2, 70f, 25, 1))
					{
						bool flag = (int)val2.playerClientId == __instance.lastPlayerSeenMoving;
						if (flag)
						{
							___timeSinceSeeingTarget = 0f;
						}
						Vector3 val3 = ((Component)__instance).transform.position - ((Component)StartOfRound.Instance.allPlayerScripts[__instance.lastPlayerSeenMoving]).transform.position;
						float sqrMagnitude = ((Vector3)(ref val3)).sqrMagnitude;
						val3 = ((Component)__instance).transform.position - ((Component)val2).transform.position;
						float sqrMagnitude2 = ((Vector3)(ref val3)).sqrMagnitude;
						if (sqrMagnitude - sqrMagnitude2 > 9f || (___timeSinceSeeingTarget > 3f && !flag))
						{
							__instance.lastPlayerSeenMoving = (int)val2.playerClientId;
							__instance.SeeMovingThreatServerRpc((int)val2.playerClientId, false);
						}
					}
				}
				break;
			}
			}
		}

		private static bool CheckLineOfSightForPlayer(NutcrackerEnemyAI __instance, PlayerControllerB playerControllerB, float width = 45f, int range = 60, int proximityAwareness = -1)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			Vector3 position = ((Component)playerControllerB.gameplayCamera).transform.position;
			if (Vector3.Distance(position, ((EnemyAI)__instance).eye.position) < (float)range && !Physics.Linecast(((EnemyAI)__instance).eye.position, position, StartOfRound.Instance.collidersAndRoomMaskAndDefault))
			{
				Vector3 val = position - ((EnemyAI)__instance).eye.position;
				if (Vector3.Angle(((EnemyAI)__instance).eye.forward, val) < width || (proximityAwareness != -1 && Vector3.Distance(((EnemyAI)__instance).eye.position, position) < (float)proximityAwareness))
				{
					return true;
				}
			}
			return false;
		}

		public static bool IsPlayerMoving([NotNullWhen(true)] PlayerControllerB? player)
		{
			if ((Object)(object)player == (Object)null)
			{
				return false;
			}
			if (player.performingEmote)
			{
				return true;
			}
			if (player.timeSincePlayerMoving < 0.05f)
			{
				return true;
			}
			return false;
		}
	}
	[HarmonyPatch(typeof(PumaAI))]
	public class PumaAIPatch
	{
		[HarmonyPatch("DoAIInterval")]
		[HarmonyTranspiler]
		public static IEnumerable<CodeInstruction> DoAIInterval_Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator generator)
		{
			int num = -1;
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			MethodInfo methodInfo = AccessTools.PropertyGetter(typeof(GameNetworkManager), "Instance");
			FieldInfo fieldInfo = AccessTools.Field(typeof(GameNetworkManager), "localPlayerController");
			MethodInfo methodInfo2 = AccessTools.Method(typeof(Object), "op_Inequality", (Type[])null, (Type[])null);
			for (int i = 0; i < list.Count - 5; i++)
			{
				if (CodeInstructionExtensions.IsLdarg(list[i], (int?)0) && CodeInstructionExtensions.LoadsField(list[i + 1], PatchesUtil.FieldInfoTargetPlayer, false) && CodeInstructionExtensions.Calls(list[i + 2], methodInfo) && CodeInstructionExtensions.LoadsField(list[i + 3], fieldInfo, false) && CodeInstructionExtensions.Calls(list[i + 4], methodInfo2) && (list[i + 5].opcode == OpCodes.Brfalse_S || list[i + 5].opcode == OpCodes.Brfalse))
				{
					num = i;
					break;
				}
			}
			if (num > -1)
			{
				list[num].opcode = OpCodes.Nop;
				list[num].operand = null;
				list[num + 1].opcode = OpCodes.Nop;
				list[num + 1].operand = null;
				list[num + 2].opcode = OpCodes.Ldarg_0;
				list[num + 2].operand = null;
				list[num + 3].opcode = OpCodes.Ldfld;
				list[num + 3].operand = PatchesUtil.FieldInfoTargetPlayer;
				list[num + 4].opcode = OpCodes.Call;
				list[num + 4].operand = PatchesUtil.IsPlayerLocalOrLethalBotOwnerLocalMethod;
				list[num + 5].opcode = ((list[num + 5].opcode == OpCodes.Brfalse) ? OpCodes.Brtrue : OpCodes.Brtrue_S);
				num = -1;
			}
			else
			{
				Plugin.LogError("LethalBot.Patches.EnemiesPatches.PumaAIPatch.DoAIInterval_Transpiler could not check if bot or local player 1");
			}
			for (int j = 0; j < list.Count - 5; j++)
			{
				if (CodeInstructionExtensions.IsLdarg(list[j], (int?)0) && CodeInstructionExtensions.LoadsField(list[j + 1], PatchesUtil.FieldInfoTargetPlayer, false) && CodeInstructionExtensions.Calls(list[j + 2], methodInfo) && CodeInstructionExtensions.LoadsField(list[j + 3], fieldInfo, false) && CodeInstructionExtensions.Calls(list[j + 4], methodInfo2) && (list[j + 5].opcode == OpCodes.Brfalse_S || list[j + 5].opcode == OpCodes.Brfalse))
				{
					num = j;
					break;
				}
			}
			if (num > -1)
			{
				list[num].opcode = OpCodes.Nop;
				list[num].operand = null;
				list[num + 1].opcode = OpCodes.Nop;
				list[num + 1].operand = null;
				list[num + 2].opcode = OpCodes.Ldarg_0;
				list[num + 2].operand = null;
				list[num + 3].opcode = OpCodes.Ldfld;
				list[num + 3].operand = PatchesUtil.FieldInfoTargetPlayer;
				list[num + 4].opcode = OpCodes.Call;
				list[num + 4].operand = PatchesUtil.IsPlayerLocalOrLethalBotOwnerLocalMethod;
				list[num + 5].opcode = ((list[num + 5].opcode == OpCodes.Brfalse) ? OpCodes.Brtrue : OpCodes.Brtrue_S);
				num = -1;
			}
			else
			{
				Plugin.LogError("LethalBot.Patches.EnemiesPatches.PumaAIPatch.DoAIInterval_Transpiler could not check if bot or local player 2");
			}
			return list.AsEnumerable();
		}

		[HarmonyPatch("Update")]
		[HarmonyTranspiler]
		public static IEnumerable<CodeInstruction> Update_Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator generator)
		{
			int num = -1;
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			MethodInfo methodInfo = AccessTools.PropertyGetter(typeof(GameNetworkManager), "Instance");
			FieldInfo fieldInfo = AccessTools.Field(typeof(GameNetworkManager), "localPlayerController");
			MethodInfo methodInfo2 = AccessTools.Method(typeof(Object), "op_Inequality", (Type[])null, (Type[])null);
			for (int i = 0; i < list.Count - 5; i++)
			{
				if (CodeInstructionExtensions.IsLdarg(list[i], (int?)0) && CodeInstructionExtensions.LoadsField(list[i + 1], PatchesUtil.FieldInfoTargetPlayer, false) && CodeInstructionExtensions.Calls(list[i + 2], methodInfo) && CodeInstructionExtensions.LoadsField(list[i + 3], fieldInfo, false) && CodeInstructionExtensions.Calls(list[i + 4], methodInfo2) && (list[i + 5].opcode == OpCodes.Brfalse_S || list[i + 5].opcode == OpCodes.Brfalse))
				{
					num = i;
					break;
				}
			}
			if (num > -1)
			{
				list[num].opcode = OpCodes.Nop;
				list[num].operand = null;
				list[num + 1].opcode = OpCodes.Nop;
				list[num + 1].operand = null;
				list[num + 2].opcode = OpCodes.Ldarg_0;
				list[num + 2].operand = null;
				list[num + 3].opcode = OpCodes.Ldfld;
				list[num + 3].operand = PatchesUtil.FieldInfoTargetPlayer;
				list[num + 4].opcode = OpCodes.Call;
				list[num + 4].operand = PatchesUtil.IsPlayerLocalOrLethalBotOwnerLocalMethod;
				list[num + 5].opcode = ((list[num + 5].opcode == OpCodes.Brfalse) ? OpCodes.Brtrue : OpCodes.Brtrue_S);
				num = -1;
			}
			else
			{
				Plugin.LogError("LethalBot.Patches.EnemiesPatches.PumaAIPatch.Update_Transpiler could not check if bot or local player 1");
			}
			return list.AsEnumerable();
		}
	}
	[HarmonyPatch(typeof(RadMechAI))]
	public class RadMechAIPatch
	{
		private static MethodInfo IsLocalPlayerOrLethalBotCloseToPosMethod = SymbolExtensions.GetMethodInfo(Expression.Lambda<Action>(Expression.Call(null, (MethodInfo)MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), new Expression[2]
		{
			Expression.New(typeof(Vector3)),
			Expression.New(typeof(Vector3))
		}), Array.Empty<ParameterExpression>()));

		[HarmonyPatch("Stomp")]
		[HarmonyPostfix]
		private static void Stomp_Postfix(RadMechAI __instance, Transform stompTransform, ParticleSystem particle, ParticleSystem particle2, float radius)
		{
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: 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_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0109: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			LethalBotAI[] lethalBotsAIOwnedByLocal = LethalBotManager.Instance.GetLethalBotsAIOwnedByLocal();
			LethalBotAI[] array = lethalBotsAIOwnedByLocal;
			for (int i = 0; i < array.Length; i++)
			{
				PlayerControllerB val = array[i]?.NpcController?.Npc;
				if (!((Object)(object)val != (Object)null))
				{
					continue;
				}
				float num = Vector3.Distance(((Component)val).transform.position, stompTransform.position);
				Vector3 val2 = Vector3.Normalize(((Component)val.gameplayCamera).transform.position - stompTransform.position) * 15f / Vector3.Distance(((Component)val.gameplayCamera).transform.position, stompTransform.position);
				if (num < radius)
				{
					if ((double)num < (double)radius * 0.175)
					{
						val.DamagePlayer(70, true, true, (CauseOfDeath)8, 0, false, Vector3.down * 40f);
					}
					else if (num < radius * 0.5f)
					{
						val.DamagePlayer(30, true, true, (CauseOfDeath)8, 0, false, Vector3.down * 40f);
					}
					val.externalForceAutoFade += val2;
				}
			}
		}

		[HarmonyPatch("DoFootstepCycle")]
		[HarmonyPrefix]
		private static void DoFootstepCycle_Prefix(RadMechAI __instance, bool __runOriginal, ref bool ___disableWalking, ref float ___beginChargingTimer, ref bool ___startedChargeEffect)
		{
			//IL_003f: 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_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_010d: Unknown result type (might be due to invalid IL or missing references)
			if (!((NetworkBehaviour)__instance).IsServer || !__runOriginal || !__instance.chargingForward || ___disableWalking || __instance.aimingGun || ___beginChargingTimer < 0.4f || ___startedChargeEffect)
			{
				return;
			}
			Vector3 val = ((Component)__instance).transform.position - ((Component)__instance).transform.forward * 5f;
			Vector3 val2 = val - ((Component)GameNetworkManager.Instance.localPlayerController).transform.position;
			float sqrMagnitude = ((Vector3)(ref val2)).sqrMagnitude;
			if (sqrMagnitude < 144f)
			{
				return;
			}
			LethalBotAI[] lethalBotsAIOwnedByLocal = LethalBotManager.Instance.GetLethalBotsAIOwnedByLocal();
			LethalBotAI[] array = lethalBotsAIOwnedByLocal;
			for (int i = 0; i < array.Length; i++)
			{
				PlayerControllerB val3 = array[i]?.NpcController?.Npc;
				if ((Object)(object)val3 != (Object)null)
				{
					val2 = val - ((Component)val3).transform.position;
					float sqrMagnitude2 = ((Vector3)(ref val2)).sqrMagnitude;
					if (sqrMagnitude2 < 144f)
					{
						Landmine.SpawnExplosion(((Component)__instance).transform.position + Vector3.up * 0.2f, false, 2f, 5f, 30, 45f, (GameObject)null, false);
						break;
					}
				}
			}
		}

		[HarmonyPatch("SetExplosion")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> SetExplosion_Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator generator)
		{
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Expected O, but got Unknown
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Expected O, but got Unknown
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: Expected O, but got Unknown
			//IL_011b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0127: 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");
			Plugin.LogDebug("Beginning to patch RadMechAI.SetExplosion!");
			for (int i = 0; i < list.Count - 11; i++)
			{
				if (CodeInstructionExtensions.Calls(list[i], methodInfo) && CodeInstructionExtensions.LoadsField(list[i + 1], fieldInfo, false) && list[i + 11].opcode == OpCodes.Bge_Un)
				{
					num = i;
					break;
				}
			}
			if (num > -1)
			{
				List<Label> labels = list[num + 11].labels;
				Label label = (Label)list[num + 11].operand;
				list.RemoveRange(num, 12);
				list.InsertRange(num, new List<CodeInstruction>
				{
					new CodeInstruction(OpCodes.Ldarg_1, (object)null),
					new CodeInstruction(OpCodes.Ldarg_2, (object)null),
					new CodeInstruction(OpCodes.Call, (object)IsLocalPlayerOrLethalBotCloseToPosMethod),
					CodeInstructionExtensions.WithLabels(new CodeInstruction(OpCodes.Brfalse, (object)label), (IEnumerable<Label>)labels)
				});
				num = -1;
			}
			else
			{
				Plugin.LogError("LethalBot.Patches.EnemiesPatches.RadMechAI.SetExplosion_Transpiler could not change local explostion distance checks!");
			}
			Plugin.LogDebug("Finished patching RadMechAI.SetExplosion!");
			return list.AsEnumerable();
		}

		private static bool IsLocalPlayerOrLethalBotCloseToPos(Vector3 explosionPosition, Vector3 forwardRotation)
		{
			//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_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = explosionPosition - forwardRotation * 0.1f;
			Vector3 val2 = ((Component)GameNetworkManager.Instance.localPlayerController).transform.position - val;
			if (((Vector3)(ref val2)).sqrMagnitude < 64f)
			{
				return true;
			}
			LethalBotAI[] lethalBotsAIOwnedByLocal = LethalBotManager.Instance.GetLethalBotsAIOwnedByLocal();
			LethalBotAI[] array = lethalBotsAIOwnedByLocal;
			foreach (LethalBotAI lethalBotAI in array)
			{
				if (!((Object)(object)lethalBotAI != (Object)null))
				{
					continue;
				}
				PlayerControllerB npc = lethalBotAI.NpcController.Npc;
				if ((Object)(object)npc != (Object)null && !npc.isPlayerDead)
				{
					val2 = ((Component)npc).transform.position - val;
					if (((Vector3)(ref val2)).sqrMagnitude < 64f)
					{
						return true;
					}
				}
			}
			return false;
		}
	}
	[HarmonyPatch(typeof(RadMechMissile))]
	public class RadMechMissilePatch
	{
		[HarmonyPatch("CheckCollision")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> CheckCollision_Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator generator)
		{
			int num = -1;
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			for (int i = 0; i < list.Count - 2; i++)
			{
				if (((object)list[i]).ToString() == "call static GameNetworkManager GameNetworkManager::get_Instance()" && ((object)list[i + 1]).ToString() == "ldfld GameNetcodeStuff.PlayerControllerB GameNetworkManager::localPlayerController" && ((object)list[i + 2]).ToString() == "call static bool UnityEngine.Object::op_Equality(UnityEngine.Object x, UnityEngine.Object y)")
				{
					num = i;
					break;
				}
			}
			if (num > -1)
			{
				list[num].opcode = OpCodes.Call;
				list[num].operand = PatchesUtil.IsPlayerLocalOrLethalBotOwnerLocalMethod;
				list[num + 1].opcode = OpCodes.Nop;
				list[num + 1].operand = null;
				list[num + 2].opcode = OpCodes.Nop;
				list[num + 2].operand = null;
				num = -1;
			}
			else
			{
				Plugin.LogError("LethalBot.Patches.EnemiesPatches.RadMechMissile.CheckCollision_Transpiler could not check if bots collide with missile.");
			}
			return list.AsEnumerable();
		}
	}
	[HarmonyPatch(typeof(RedLocustBees))]
	public class RedLocustBeesPatch
	{
		[HarmonyPatch("OnCollideWithPlayer")]
		[HarmonyTranspiler]
		public static IEnumerable<CodeInstruction> OnCollideWithPlayer_Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator generator)
		{
			int num = -1;
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			for (int i = 0; i < list.Count - 4; i++)
			{
				if (((object)list[i]).ToString() == "call static GameNetworkManager GameNetworkManager::get_Instance()" && ((object)list[i + 4]).ToString() == "call void RedLocustBees::BeeKillPlayerOnLocalClient(int playerId)")
				{
					num = i;
					break;
				}
			}
			if (num > -1)
			{
				list[num].opcode = OpCodes.Nop;
				list[num].operand = null;
				list[num + 1].opcode = OpCodes.Ldloc_0;
				list[num + 1].operand = null;
				num = -1;
			}
			else
			{
				Plugin.LogError("LethalBot.Patches.EnemiesPatches.RedLocustBeesPatch.OnCollideWithPlayer_Transpiler could not call BeeKillPlayerOnLocalClient on player id.");
			}
			for (int j = 0; j < list.Count - 4; j++)
			{
				if (((object)list[j]).ToString() == "call static GameNetworkManager GameNetworkManager::get_Instance()" && ((object)list[j + 4]).ToString() == "call void RedLocustBees::BeeKillPlayerServerRpc(int playerId)")
				{
					num = j;
					break;
				}
			}
			if (num > -1)
			{
				list[num].opcode = OpCodes.Nop;
				list[num].operand = null;
				list[num + 1].opcode = OpCodes.Ldloc_0;
				list[num + 1].operand = null;
				num = -1;
			}
			else
			{
				Plugin.LogError("LethalBot.Patches.EnemiesPatches.RedLocustBeesPatch.OnCollideWithPlayer_Transpiler could not call BeeKillPlayerServerRpc on player id.");
			}
			for (int k = 0; k < list.Count - 4; k++)
			{
				if (((object)list[k]).ToString() == "call static GameNetworkManager GameNetworkManager::get_Instance()" && ((object)list[k + 4]).ToString() == "call void RedLocustBees::EnterAttackZapModeServerRpc(int clientWhoSent)")
				{
					num = k;
					break;
				}
			}
			if (num > -1)
			{
				list[num].opcode = OpCodes.Nop;
				list[num].operand = null;
				list[num + 1].opcode = OpCodes.Ldloc_0;
				list[num + 1].operand = null;
				num = -1;
			}
			else
			{
				Plugin.LogError("LethalBot.Patches.EnemiesPatches.RedLocustBeesPatch.OnCollideWithPlayer_Transpiler could not call EnterAttackZapModeServerRpc player on player id.");
			}
			return list.AsEnumerable();
		}
	}
	[HarmonyPatch(typeof(SandSpiderAI))]
	public class SandSpiderAIPatch
	{
		[HarmonyPatch("OnCollideWithPlayer")]
		[HarmonyTranspiler]
		public static IEnumerable<CodeInstruction> OnCollideWithPlayer_Transpiler(IEnumerable<CodeInstruction> instructions)
		{
			int num = -1;
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			for (int i = 0; i < list.Count - 5; i++)
			{
				if (((object)list[i]).ToString() == "ldarg.0 NULL" && ((object)list[i + 1]).ToString() == "call static GameNetworkManager GameNetworkManager::get_Instance()" && ((object)list[i + 2]).ToString() == "ldfld GameNetcodeStuff.PlayerControllerB GameNetworkManager::localPlayerController" && ((object)list[i + 5]).ToString() == "call void SandSpiderAI::HitPlayerServerRpc(int playerId)")
				{
					num = i;
					break;
				}
			}
			if (num > -1)
			{
				list[num + 1].opcode = OpCodes.Nop;
				list[num + 1].operand = null;
				list[num + 2].opcode = OpCodes.Ldloc_0;
				list[num + 2].operand = null;
				num = -1;
			}
			else
			{
				Plugin.LogError("LethalBot.Patches.EnemiesPatches.SandSpiderAIPatch.OnCollideWithPlayer_Transpiler could not change use of correct player id for HitPlayerServerRpc.");
			}
			return list.AsEnumerable();
		}
	}
	[HarmonyPatch(typeof(SandWormAI))]
	public class SandWormAIPatch
	{
		[HarmonyPatch("OnCollideWithPlayer")]
		[HarmonyTranspiler]
		public static IEnumerable<CodeInstruction> OnCollideWithPlayer_Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator generator)
		{
			int num = -1;
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			for (int i = 0; i < list.Count - 6; i++)
			{
				if (((object)list[i]).ToString() == "call static GameNetworkManager GameNetworkManager::get_Instance()" && ((object)list[i + 1]).ToString() == "ldfld GameNetcodeStuff.PlayerControllerB GameNetworkManager::localPlayerController" && ((object)list[i + 6]).ToString() == "call void SandWormAI::EatPlayer(GameNetcodeStuff.PlayerControllerB playerScript)")
				{
					num = i;
					break;
				}
			}
			if (num > -1)
			{
				list[num].opcode = OpCodes.Nop;
				list[num].operand = null;
				list[num + 1].opcode = OpCodes.Nop;
				list[num + 1].operand = null;
				list[num + 2].opcode = OpCodes.Call;
				list[num + 2].operand = PatchesUtil.IsPlayerLocalOrLethalBotOwnerLocalMethod;
				num = -1;
			}
			else
			{
				Plugin.LogError("LethalBot.Patches.EnemiesPatches.SandWormAIPatch.OnCollideWithPlayer_Transpiler could not check if player local or bot");
			}
			return list.AsEnumerable();
		}
	}
	[HarmonyPatch(typeof(SpringManAI))]
	public class SpringManAIPatch
	{
		[HarmonyPatch("Update")]
		[HarmonyTranspiler]
		public static IEnumerable<CodeInstruction> Update_Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator generator)
		{
			int num = -1;
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			for (int i = 0; i < list.Count; i++)
			{
				if (((object)list[i]).ToString() == "ldc.i4.4 NULL" || ((object)list[i]).ToString() == "ldsfld int MoreCompany.MainClass::newPlayerCount")
				{
					num = i;
					break;
				}
			}
			if (num > -1)
			{
				list[num].opcode = OpCodes.Call;
				list[num].operand = PatchesUtil.AllEntitiesCountMethod;
				num = -1;
			}
			else
			{
				Plugin.LogError("LethalBot.Patches.EnemiesPatches.SpringManAIPatch.Update_Transpiler could not change size of player array to look up.");
			}
			return list.AsEnumerable();
		}

		[HarmonyPatch("DoSpringAnimation")]
		[HarmonyPostfix]
		public static void DoSpringAnimation_Postfix(SpringManAI __instance, bool springPopUp = false)
		{
			//IL_0047: 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_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			LethalBotAI[] lethalBotsAIOwnedByLocal = LethalBotManager.Instance.GetLethalBotsAIOwnedByLocal();
			LethalBotAI[] array = lethalBotsAIOwnedByLocal;
			for (int i = 0; i < array.Length; i++)
			{
				PlayerControllerB val = array[i]?.NpcController?.Npc;
				if ((Object)(object)val != (Object)null && val.HasLineOfSightToPosition(((Component)__instance).transform.position + Vector3.up * 0.6f, 70f, 25, -1f, -1))
				{
					float num = Vector3.Distance(((Component)__instance).transform.position, ((Component)val).transform.position);
					if (num < 4f)
					{
						val.JumpToFearLevel(0.9f, true);
					}
					else if (num < 9f)
					{
						val.JumpToFearLevel(0.4f, true);
					}
				}
			}
		}
	}
}
namespace LethalBots.NetworkSerializers
{
	[Serializable]
	public struct ConfigIdentity : INetworkSerializable
	{
		public string name;

		public int suitID;

		public int suitConfigOption;

		public int defaultAIState;

		public string voiceFolder;

		public float volume;

		public float voicePitch;

		public string loadoutName;

		public string moreCompanyCosmetics;

		public int groupID;

		public ConfigIdentity()
		{
			voicePitch = 0f;
			name = "Bot #{0}";
			suitConfigOption = 1;
			suitID = 0;
			voiceFolder = "Mathew_kelly";
			volume = 0.5f;
			defaultAIState = 0;
			loadoutName = "Empty";
			moreCompanyCosmetics = string.Empty;
			groupID = -1;
		}

		public ConfigIdentity(string name, int suitID, int suitConfigOption, int defaultAIState, string voiceFolder, float volume, float voicePitch, string loadoutName, string moreCompanyCosmetics, int groupID)
		{
			this.name = name;
			this.suitID = suitID;
			this.suitConfigOption = suitConfigOption;
			this.defaultAIState = defaultAIState;
			this.voiceFolder = voiceFolder;
			this.volume = volume;
			this.voicePitch = voicePitch;
			this.loadoutName = loadoutName;
			this.moreCompanyCosmetics = moreCompanyCosmetics;
			this.groupID = groupID;
		}

		public unsafe void NetworkSerialize<T>(BufferSerializer<T> serializer) where T : IReaderWriter
		{
			//IL_0018: 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_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: 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_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			serializer.SerializeValue(ref name, false);
			((BufferSerializer<int>*)(&serializer))->SerializeValue<int>(ref suitID, default(ForPrimitives));
			((BufferSerializer<int>*)(&serializer))->SerializeValue<int>(ref suitConfigOption, default(ForPrimitives));
			((BufferSerializer<int>*)(&serializer))->SerializeValue<int>(ref defaultAIState, default(ForPrimitives));
			serializer.SerializeValue(ref voiceFolder, false);
			((BufferSerializer<float>*)(&serializer))->SerializeValue<float>(ref volume, default(ForPrimitives));
			((BufferSerializer<float>*)(&serializer))->SerializeValue<float>(ref voicePitch, default(ForPrimitives));
			serializer.SerializeValue(ref loadoutName, false);
			serializer.SerializeValue(ref moreCompanyCosmetics, false);
			((BufferSerializer<int>*)(&serializer))->SerializeValue<int>(ref groupID, default(ForPrimitives));
		}

		public override string ToString()
		{
			return $"name: {name}, suitID {suitID}, suitConfigOption {suitConfigOption} {(EnumOptionSuitConfig)suitConfigOption}, defaultAIState {defaultAIState} {(EnumDefaultAIState)defaultAIState} voiceFolder {voiceFolder}, volume {volume}, voicePitch {voicePitch}, loadoutName {loadoutName}, more company cosmetics {moreCompanyCosmetics} internal groupID: {groupID}";
		}
	}
	public struct ConfigIdentitiesNetworkSerializable : INetworkSerializable
	{
		public ConfigIdentity[] ConfigIdentities;

		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<ConfigIdentity>*)(&serializer))->SerializeValue<ConfigIdentity>(ref ConfigIdentities, default(ForNetworkSerializable));
		}
	}
	[Serializable]
	public struct ConfigLoadout : INetworkSerializable
	{
		public string name;

		public string[] itemNames;

		public ConfigLoadout()
		{
			name = "Empty";
			itemNames = new string[0];
		}

		public void NetworkSerialize<T>(BufferSerializer<T> serializer) where T : IReaderWriter
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			serializer.SerializeValue(ref name, false);
			LethalBotNetworkSerializer.SerializeStringArray<T>(serializer, ref itemNames);
		}

		public override string ToString()
		{
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.AppendLine("Loadout Name: " + name);
			stringBuilder.AppendLine("Items:");
			if (itemNames.Length == 0)
			{
				stringBuilder.AppendLine("(None)");
			}
			else
			{
				string[] array = itemNames;
				foreach (string text in array)
				{
					if (text == null)
					{
						stringBuilder.AppendLine("(null Item)");
					}
					else
					{
						stringBuilder.AppendLine("Name: " + text);
					}
				}
			}
			return stringBuilder.ToString();
		}
	}
	public struct ConfigLoadoutsNetworkSerializable : INetworkSerializable
	{
		public ConfigLoadout[] ConfigLoadouts;

		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<ConfigLoadout>*)(&serializer))->SerializeValue<ConfigLoadout>(ref ConfigLoadouts, default(ForNetworkSerializable));
		}
	}
	[Serializable]
	public struct ConfigStockRequirement : INetworkSerializable
	{
		public string itemName;

		public int desiredStock;

		public bool overrideEcoLimit;

		public int ecoLimit;

		public ConfigStockRequiredItem[] requiredItems;

		[Obsolete("requiredItemName has been superceded by requiredItems. You should use it instead. This will be removed in later versions!")]
		public string requiredItemName;

		public ConfigStockRequirement()
		{
			itemName = "None";
			desiredStock = 0;
			overrideEcoLimit = false;
			ecoLimit = 0;
			requiredItems = new ConfigStockRequiredItem[0];
			requiredItemName = "None";
		}

		public unsafe void NetworkSerialize<T>(BufferSerializer<T> serializer) where T : IReaderWriter
		{
			//IL_0018: 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_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: 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_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			serializer.SerializeValue(ref itemName, false);
			((BufferSerializer<int>*)(&serializer))->SerializeValue<int>(ref desiredStock, default(ForPrimitives));
			((BufferSerializer<bool>*)(&serializer))->SerializeValue<bool>(ref overrideEcoLimit, default(ForPrimitives));
			((BufferSerializer<int>*)(&serializer))->SerializeValue<int>(ref ecoLimit, default(ForPrimitives));
			((BufferSerializer<ConfigStockRequiredItem>*)(&serializer))->SerializeValue<ConfigStockRequiredItem>(ref requiredItems, default(ForNetworkSerializable));
		}

		public override string ToString()
		{
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.AppendLine("Item Name: " + itemName);
			stringBuilder.AppendLine($"Desired Stock: {desiredStock}");
			stringBuilder.AppendLine($"Override Eco Limit: {overrideEcoLimit}");
			stringBuilder.AppendLine($"Eco Limit: {ecoLimit}");
			stringBuilder.AppendLine("Required Items:");
			if (requiredItems == null || requiredItems.Length == 0)
			{
				stringBuilder.AppendLine("(None)");
			}
			else
			{
				ConfigStockRequiredItem[] array = requiredItems;
				foreach (ConfigStockRequiredItem configStockRequiredItem in array)
				{
					stringBuilder.AppendLine($"{configStockRequiredItem}");
				}
			}
			return stringBuilder.ToString();
		}
	}
	[Serializable]
	public struct ConfigStockRequiredItem : INetworkSerializable
	{
		public string itemName;

		public int requiredStock;

		public ConfigStockRequiredItem()
		{
			itemName = string.Empty;
			requiredStock = 0;
		}

		public unsafe void NetworkSerialize<T>(BufferSerializer<T> serializer) where T : IReaderWriter
		{
			//IL_0018: 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)
			serializer.SerializeValue(ref itemName, false);
			((BufferSerializer<int>*)(&serializer))->SerializeValue<int>(ref requiredStock, default(ForPrimitives));
		}

		public override string ToString()
		{
			return $"Item Name: {itemName} and Requred Stock: {requiredStock}";
		}
	}
	public struct ConfigStockRequirementNetworkSerializable : INetworkSerializable
	{
		public ConfigStockRequirement[] ConfigStockRequirements;

		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<ConfigStockRequirement>*)(&serializer))->SerializeValue<ConfigStockRequirement>(ref ConfigStockRequirements, default(ForNetworkSerializable));
		}
	}
	public struct DropItemNetworkSerializable : INetworkSerializable
	{
		public NetworkObjectReference GrabbedObject;

		public bool DroppedInElevator;

		public bool DroppedInShipRoom;

		public Vector3 TargetFloorPosition;

		public int FloorYRot;

		public ulong? SkipPlayer;

		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_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			((BufferSerializer<NetworkObjectReference>*)(&serializer))->SerializeValue<NetworkObjectReference>(ref GrabbedObject, default(ForNetworkSerializable));
			((BufferSerializer<bool>*)(&serializer))->SerializeValue<bool>(ref DroppedInElevator, default(ForPrimitives));
			((BufferSerializer<bool>*)(&serializer))->SerializeValue<bool>(ref DroppedInShipRoom, default(ForPrimitives));
			serializer.SerializeValue(ref TargetFloorPosition);
			((BufferSerializer<int>*)(&serializer))->SerializeValue<int>(ref FloorYRot, default(ForPrimitives));
			LethalBotNetworkSerializer.SerializeNullable<ulong, T>(serializer, ref SkipPlayer);
		}
	}
	[Serializable]
	public struct LethalBotGroupMemberNetworkSerializable : INetworkSerializable, IEquatable<LethalBotGroupMemberNetworkSerializable>
	{
		public int GroupId;

		public NetworkBehaviourReference Member;

		public bool IsLeader;

		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)
			((BufferSerializer<int>*)(&serializer))->SerializeValue<int>(ref GroupId, default(ForPrimitives));
			((BufferSerializer<NetworkBehaviourReference>*)(&serializer))->SerializeValue<NetworkBehaviourReference>(ref Member, default(ForNetworkSerializable));
			((BufferSerializer<bool>*)(&serializer))->SerializeValue<bool>(ref IsLeader, default(ForPrimitives));
		}

		public bool Equals(LethalBotGroupMemberNetworkSerializable other)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			if (GroupId == other.GroupId && ((NetworkBehaviourReference)(ref Member)).Equals(other.Member))
			{
				return IsLeader == other.IsLeader;
			}
			return false;
		}

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

		public override int GetHashCode()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			return HashCode.Combine<int, NetworkBehaviourReference, bool>(GroupId, Member, IsLeader);
		}

		public static bool operator ==(LethalBotGroupMemberNetworkSerializable? left, LethalBotGroupMemberNetworkSerializable? right)
		{
			if (!left.HasValue && !right.HasValue)
			{
				return true;
			}
			if (!left.HasValue || !right.HasValue)
			{
				return false;
			}
			return left.Equals(right);
		}

		public static bool operator !=(LethalBotGroupMemberNetworkSerializable? left, LethalBotGroupMemberNetworkSerializable? right)
		{
			return !(left == right);
		}
	}
	public static class LethalBotNetworkSerializer
	{
		public unsafe static void SerializeNullable<T, TReaderWriter>(BufferSerializer<TReaderWriter> serializer, ref T? value) where T : unmanaged, IComparable, IConvertible, IComparable<T>, IEquatable<T> where TReaderWriter : IReaderWriter
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			bool hasValue = value.HasValue;
			((BufferSerializer<?>*)(&serializer))->SerializeValue<bool>(ref hasValue, default(ForPrimitives));
			if (hasValue)
			{
				T valueOrDefault = value.GetValueOrDefault();
				((BufferSerializer<?>*)(&serializer))->SerializeValue<T>(ref valueOrDefault, default(ForPrimitives));
				if (serializer.IsReader)
				{
					value = valueOrDefault;
				}
			}
			else if (serializer.IsReader)
			{
				value = null;
			}
		}

		public unsafe static void SerializeNullable<TReaderWriter>(BufferSerializer<TReaderWriter> serializer, ref Vector3? value) where TReaderWriter : IReaderWriter
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: 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_0036: Unknown result type (might be due to invalid IL or missing references)
			bool hasValue = value.HasValue;
			((BufferSerializer<bool>*)(&serializer))->SerializeValue<bool>(ref hasValue, default(ForPrimitives));
			if (hasValue)
			{
				Vector3 valueOrDefault = value.GetValueOrDefault();
				serializer.SerializeValue(ref valueOrDefault);
				if (serializer.IsReader)
				{
					value = valueOrDefault;
				}
			}
			else if (serializer.IsReader)
			{
				value = null;
			}
		}

		public unsafe static void SerializeNullable<TReaderWriter>(BufferSerializer<TReaderWriter> serializer, ref NetworkObjectReference? value) where TReaderWriter : IReaderWriter
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: 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_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			bool hasValue = value.HasValue;
			((BufferSerializer<bool>*)(&serializer))->SerializeValue<bool>(ref hasValue, default(ForPrimitives));
			if (hasValue)
			{
				NetworkObjectReference valueOrDefault = value.GetValueOrDefault();
				((BufferSerializer<NetworkObjectReference>*)(&serializer))->SerializeValue<NetworkObjectReference>(ref valueOrDefault, default(ForNetworkSerializable));
				if (serializer.IsReader)
				{
					value = valueOrDefault;
				}
			}
			else if (serializer.IsReader)
			{
				value = null;
			}
		}

		public unsafe static void SerializeNullable<TReaderWriter>(BufferSerializer<TReaderWriter> serializer, ref NetworkBehaviourReference? value) where TReaderWriter : IReaderWriter
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: 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_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			bool hasValue = value.HasValue;
			((BufferSerializer<bool>*)(&serializer))->SerializeValue<bool>(ref hasValue, default(ForPrimitives));
			if (hasValue)
			{
				NetworkBehaviourReference valueOrDefault = value.GetValueOrDefault();
				((BufferSerializer<NetworkBehaviourReference>*)(&serializer))->SerializeValue<NetworkBehaviourReference>(ref valueOrDefault, default(ForNetworkSerializable));
				if (serializer.IsReader)
				{
					value = valueOrDefault;
				}
			}
			else if (serializer.IsReader)
			{
				value = null;
			}
		}

		public unsafe static void SerializeStringArray<TReaderWriter>(BufferSerializer<TReaderWriter> serializer, ref string[] value) where TReaderWriter : IReaderWriter
		{
			//IL_000b: 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)
			int num = value.Length;
			((BufferSerializer<int>*)(&serializer))->SerializeValue<int>(ref num, default(ForPrimitives));
			if (serializer.IsReader)
			{
				value = new string[num];
			}
			for (int i = 0; i < num; i++)
			{
				serializer.SerializeValue(ref value[i], false);
			}
		}
	}
	[Serializable]
	public class LookAtTarget : INetworkSerializable, IEquatable<LookAtTarget>
	{
		public Vector3 lookAtPos;

		public NetworkObjectReference? lookAtSubject;

		public EnumLookAtPriority lookAtPriority;

		public CountdownTimer lookAtExpireTimer;

		public CountdownTimer lookAtTrackingTimer;

		public IntervalTimer lookAtDurationTimer;

		public bool isSightedIn;

		public bool hasBeenSightedIn;

		public IntervalTimer headSteadyTimer;

		public Vector3 directionToUpdateTurnBodyTowardsTo;

		public float maxBodyFOV;

		public EnumObjectsLookingAt enumObjectsLookingAt;

		private Vector3 lastDirectionToLookAt;

		private Quaternion cameraRotationToUpdateLookAt;

		public const float ON_TARGET_TOLERANCE = 0.98f;

		public LookAtTarget()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			lookAtPos = Vector3.zero;
			lookAtSubject = null;
			lookAtPriority = EnumLookAtPriority.LOW_PRIORITY;
			lookAtExpireTimer = new CountdownTimer();
			lookAtTrackingTimer = new CountdownTimer();
			lookAtDurationTimer = new IntervalTimer();
			isSightedIn = false;
			hasBeenSightedIn = false;
			headSteadyTimer = new IntervalTimer();
			maxBodyFOV = 90f;
			enumObjectsLookingAt = EnumObjectsLookingAt.Forward;
		}

		public unsafe void NetworkSerialize<T>(BufferSerializer<T> serializer) where T : IReaderWriter
		{
			//IL_000d: 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_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			serializer.SerializeValue(ref lookAtPos);
			LethalBotNetworkSerializer.SerializeNullable<T>(serializer, ref lookAtSubject);
			((BufferSerializer<EnumLookAtPriority>*)(&serializer))->SerializeValue<EnumLookAtPriority>(ref lookAtPriority, default(ForEnums));
			((BufferSerializer<CountdownTimer>*)(&serializer))->SerializeValue<CountdownTimer>(ref lookAtExpireTimer, default(ForNetworkSerializable));
			((BufferSerializer<CountdownTimer>*)(&serializer))->SerializeValue<CountdownTimer>(ref lookAtTrackingTimer, default(ForNetworkSerializable));
			((BufferSerializer<IntervalTimer>*)(&serializer))->SerializeValue<IntervalTimer>(ref lookAtDurationTimer, default(ForNetworkSerializable));
			((BufferSerializer<bool>*)(&serializer))->SerializeValue<bool>(ref isSightedIn, default(ForPrimitives));
			((BufferSerializer<bool>*)(&serializer))->SerializeValue<bool>(ref hasBeenSightedIn, default(ForPrimitives));
			((BufferSerializer<IntervalTimer>*)(&serializer))->SerializeValue<IntervalTimer>(ref headSteadyTimer, default(ForNetworkSerializable));
			serializer.SerializeValue(ref directionToUpdateTurnBodyTowardsTo);
			((BufferSerializer<float>*)(&serializer))->SerializeValue<float>(ref maxBodyFOV, default(ForPrimitives));
			((BufferSerializer<EnumObjectsLookingAt>*)(&serializer))->SerializeValue<EnumObjectsLookingAt>(ref enumObjectsLookingAt, default(ForEnums));
		}

		public bool IsLookingForward()
		{
			return enumObjectsLookingAt == EnumObjectsLookingAt.Forward;
		}

		public bool CanSwapAimState(EnumLookAtPriority priority = EnumLookAtPriority.LOW_PRIORITY, bool lookAtMustExpire = false, bool bypassSteadyCheck = false)
		{
			if (lookAtPriority == priority && !bypassSteadyCheck && (!IsHeadSteady() || GetHeadSteadyDuration() < 0.3f))
			{
				return false;
			}
			if ((lookAtMustExpire || lookAtPriority > priority) && !lookAtExpireTimer.Elapsed())
			{
				return false;
			}
			return true;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public bool IsHeadAimingOnTarget()
		{
			return isSightedIn;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public bool IsHeadSteady()
		{
			return headSteadyTimer.HasStarted();
		}

		public float GetHeadSteadyDuration()
		{
			if (headSteadyTimer.HasStarted())
			{
				return headSteadyTimer.GetElapsedTime();
			}
			return 0f;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public LookAtTarget Clone()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			return new LookAtTarget
			{
				lookAtPos = lookAtPos,
				lookAtSubject = lookAtSubject,
				lookAtPriority = lookAtPriority,
				lookAtExpireTimer = lookAtExpireTimer.Clone(),
				lookAtTrackingTimer = lookAtTrackingTimer.Clone(),
				lookAtDurationTimer = lookAtDurationTimer.Clone(),
				isSightedIn = isSightedIn,
				hasBeenSightedIn = hasBeenSightedIn,
				headSteadyTimer = headSteadyTimer.Clone(),
				directionToUpdateTurnBodyTowardsTo = directionToUpdateTurnBodyTowardsTo,
				maxBodyFOV = maxBodyFOV
			};
		}

		public void AimHeadTowards(Vector3 lookAtPos, EnumLookAtPriority priority = EnumLookAtPriority.LOW_PRIORITY, float duration = 0f, bool bypassSteadyCheck = false, float maxBodyFOV = 90f)
		{
			//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)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			if (duration <= 0f)
			{
				duration = 0.1f;
			}
			if (CanSwapAimState(priority, lookAtMustExpire: false, bypassSteadyCheck))
			{
				lookAtExpireTimer.Start(duration);
				Vector3 val = this.lookAtPos - lookAtPos;
				if (((Vector3)(ref val)).sqrMagnitude < 0.0001f)
				{
					lookAtPriority = priority;
					this.maxBodyFOV = maxBodyFOV;
					return;
				}
				this.lookAtPos = lookAtPos;
				lookAtSubject = null;
				lookAtDurationTimer.Start();
				lookAtPriority = priority;
				hasBeenSightedIn = false;
				this.maxBodyFOV = maxBodyFOV;
			}
		}

		public void AimHeadTowards(NetworkObjectReference lookAtSubject, EnumLookAtPriority priority = EnumLookAtPriority.LOW_PRIORITY, float duration = 0f, bool bypassSteadyCheck = false, float maxBodyFOV = 90f)
		{
			//IL_002e: 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)
			if (duration <= 0f)
			{
				duration = 0.1f;
			}
			if (CanSwapAimState(priority, lookAtMustExpire: false, bypassSteadyCheck))
			{
				lookAtExpireTimer.Start(duration);
				if (this.lookAtSubject.Equals(lookAtSubject))
				{
					lookAtPriority = priority;
					this.maxBodyFOV = maxBodyFOV;
					return;
				}
				this.lookAtSubject = lookAtSubject;
				lookAtDurationTimer.Start();
				lookAtPriority = priority;
				hasBeenSightedIn = false;
				this.maxBodyFOV = maxBodyFOV;
			}
		}

		public void Update(NpcController npcController, LethalBotAI lethalBotAI)
		{
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_010d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_011e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_0125: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: 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_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_01eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0210: Unknown result type (might be due to invalid IL or missing references)
			//IL_0220: Unknown result type (might be due to invalid IL or missing references)
			//IL_0187: Unknown result type (might be due to invalid IL or missing references)
			//IL_0192: Unknown result type (might be due to invalid IL or missing references)
			//IL_0244: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ca: Unknown result type (might be due to invalid IL or missing references)
			PlayerControllerB npc = npcController.Npc;
			if (!lookAtTrackingTimer.HasStarted() || lookAtTrackingTimer.Elapsed())
			{
				lookAtTrackingTimer.Start(Random.Range(0.05f, 0.3f));
				if (lookAtSubject.HasValue)
				{
					Vector3? val = lethalBotAI.State?.SelectSubjectTargetPoint(this, NetworkObjectReference.op_Implicit(lookAtSubject.Value), npc);
					if (val.HasValue)
					{
						lookAtPos = val.Value;
					}
				}
			}
			Vector3 val2 = lookAtPos - ((Component)npc.gameplayCamera).transform.position;
			if (!npcController.DirectionNotZero(val2.x) && !npcController.DirectionNotZero(val2.y) && !npcController.DirectionNotZero(val2.z))
			{
				return;
			}
			if (val2 != lastDirectionToLookAt)
			{
				lastDirectionToLookAt = val2;
				cameraRotationToUpdateLookAt = Quaternion.LookRotation(new Vector3(val2.x, val2.y, val2.z));
			}
			Vector3 normalized = ((Vector3)(ref val2)).normalized;
			Vector3 forward = ((Component)npc.gameplayCamera).transform.forward;
			if (Vector3.Dot(forward, normalized) > 0.98f)
			{
				if (!hasBeenSightedIn)
				{
					hasBeenSightedIn = true;
				}
				if (!headSteadyTimer.HasStarted())
				{
					headSteadyTimer.Start();
				}
				isSightedIn = true;
			}
			else
			{
				headSteadyTimer.Invalidate();
				isSightedIn = false;
			}
			if (enumObjectsLookingAt == EnumObjectsLookingAt.Forward)
			{
				if (!(((Component)npc.gameplayCamera).transform.rotation == npc.thisPlayerBody.rotation))
				{
					((Component)npc.gameplayCamera).transform.rotation = Quaternion.RotateTowards(((Component)npc.gameplayCamera).transform.rotation, npc.thisPlayerBody.rotation, 4f);
				}
				return;
			}
			((Component)npc.gameplayCamera).transform.rotation = Quaternion.RotateTowards(((Component)npc.gameplayCamera).transform.rotation, cameraRotationToUpdateLookAt, 4f);
			if (Vector3.Angle(((Component)npc.gameplayCamera).transform.forward, ((Component)npc.thisPlayerBody).transform.forward) > Mathf.Max(maxBodyFOV - 20f, 0f))
			{
				npcController.SetTurnBodyTowardsDirectionWithPosition(lookAtPos);
			}
		}

		public bool Equals(LookAtTarget? other)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			if ((object)other == null)
			{
				return false;
			}
			if (lookAtPos == other.lookAtPos && lookAtSubject.Equals(other.lookAtSubject) && lookAtPriority == other.lookAtPriority && lookAtExpireTimer == other.lookAtExpireTimer && lookAtTrackingTimer == other.lookAtTrackingTimer && lookAtDurationTimer == other.lookAtDurationTimer && isSightedIn == other.isSightedIn && hasBeenSightedIn == other.hasBeenSightedIn && headSteadyTimer == other.headSteadyTimer && directionToUpdateTurnBodyTowardsTo == other.directionToUpdateTurnBodyTowardsTo)
			{
				return maxBodyFOV == other.maxBodyFOV;
			}
			return false;
		}

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

		public override int GetHashCode()
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			HashCode hashCode = default(HashCode);
			hashCode.Add<Vector3>(lookAtPos);
			hashCode.Add(lookAtSubject);
			hashCode.Add(lookAtPriority);
			hashCode.Add(lookAtExpireTimer);
			hashCode.Add(lookAtTrackingTimer);
			hashCode.Add(lookAtDurationTimer);
			hashCode.Add(isSightedIn);
			hashCode.Add(hasBeenSightedIn);
			hashCode.Add(headSteadyTimer);
			hashCode.Add<Vector3>(directionToUpdateTurnBodyTowardsTo);
			hashCode.Add(maxBodyFOV);
			return hashCode.ToHashCode();
		}

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

		public static bool operator !=(LookAtTarget? left, LookAtTarget? right)
		{
			return !(left == right);
		}
	}
	public struct PlaceItemNetworkSerializable : INetworkSerializable
	{
		public NetworkObjectReference GrabbedObject;

		public NetworkObjectReference ParentObject;

		public Vector3 PlacePositionOffset;

		public bool MatchRotationOfParent;

		public ulong? SkipPlayer;

		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_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			((BufferSerializer<NetworkObjectReference>*)(&serializer))->SerializeValue<NetworkObjectReference>(ref GrabbedObject, default(ForNetworkSerializable));
			((BufferSerializer<NetworkObjectReference>*)(&serializer))->SerializeValue<NetworkObjectReference>(ref ParentObject, default(ForNetworkSerializable));
			serializer.SerializeValue(ref PlacePositionOffset);
			((BufferSerializer<bool>*)(&serializer))->SerializeValue<bool>(ref MatchRotationOfParent, default(ForPrimitives));
			LethalBotNetworkSerializer.SerializeNullable<ulong, T>(serializer, ref SkipPlayer);
		}
	}
	internal struct SaveNetworkSerializable : INetworkSerializable
	{
		public IdentitySaveFileNetworkSerializable[] Identities;

		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<IdentitySaveFileNetworkSerializable>*)(&serializer))->SerializeValue<IdentitySaveFileNetworkSerializable>(ref Identities, default(ForNetworkSerializable));
		}
	}
	internal struct IdentitySaveFileNetworkSerializable : INetworkSerializable
	{
		public int IdIdentity;

		public int SuitID;

		public int Hp;

		public int Status;

		public int XP;

		public int Level;

		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)
			((BufferSerializer<int>*)(&serializer))->SerializeValue<int>(ref IdIdentity, default(ForPrimitives));
			((BufferSerializer<int>*)(&serializer))->SerializeValue<int>(ref SuitID, default(ForPrimitives));
			((BufferSerializer<int>*)(&serializer))->SerializeValue<int>(ref Hp, default(ForPrimitives));
			((BufferSerializer<int>*)(&serializer))->SerializeValue<int>(ref Status, default(ForPrimitives));
			((BufferSerializer<int>*)(&serializer))->SerializeValue<int>(ref XP, default(ForPrimitives));
			((BufferSerializer<int>*)(&serializer))->SerializeValue<int>(ref Level, default(ForPrimitives));
		}
	}
	[Serializable]
	public struct SpawnLethalBotParamsNetworkSerializable : INetworkSerializable
	{
		public NetworkObjectReference? LethalBotReference;

		public int IndexNextLethalBot;

		public int? IndexNextPlayerObject;

		public int LethalBotIdentityID;

		public int Hp;

		public int SuitID;

		public EnumSpawnAnimation enumSpawnAnimation;

		public float? CarryWeight;

		public Vector3? SpawnPosition;

		public float YRot;

		public bool IsOutside;

		public bool ShouldDestroyDeadBody;

		public bool ResetBodyBlood;

		public SpawnLethalBotParamsNetworkSerializable()
		{
			LethalBotReference = null;
			IndexNextLethalBot = 0;
			LethalBotIdentityID = 0;
			Hp = 0;
			SuitID = 0;
			enumSpawnAnimation = EnumSpawnAnimation.None;
			CarryWeight = null;
			SpawnPosition = null;
			YRot = 0f;
			IsOutside = false;
			ShouldDestroyDeadBody = false;
			IndexNextPlayerObject = null;
			ResetBodyBlood = false;
		}

		public unsafe void NetworkSerialize<T>(BufferSerializer<T> serializer) where T : IReaderWriter
		{
			//IL_0000: 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_001c: 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_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			LethalBotNetworkSerializer.SerializeNullable<T>(serializer, ref LethalBotReference);
			((BufferSerializer<int>*)(&serializer))->SerializeValue<int>(ref IndexNextLethalBot, default(ForPrimitives));
			LethalBotNetworkSerializer.SerializeNullable<int, T>(serializer, ref IndexNextPlayerObject);
			((BufferSerializer<int>*)(&serializer))->SerializeValue<int>(ref LethalBotIdentityID, default(ForPrimitives));
			((BufferSerializer<int>*)(&serializer))->SerializeValue<int>(ref Hp, default(ForPrimitives));
			((BufferSerializer<int>*)(&serializer))->SerializeValue<int>(ref SuitID, default(ForPrimitives));
			((BufferSerializer<EnumSpawnAnimation>*)(&serializer))->SerializeValue<EnumSpawnAnimation>(ref enumSpawnAnimation, default(ForEnums));
			LethalBotNetworkSerializer.SerializeNullable<float, T>(serializer, ref CarryWeight);
			LethalBotNetworkSerializer.SerializeNullable<T>(serializer, ref SpawnPosition);
			((BufferSerializer<float>*)(&serializer))->SerializeValue<float>(ref YRot, default(ForPrimitives));
			((BufferSerializer<bool>*)(&serializer))->SerializeValue<bool>(ref IsOutside, default(ForPrimitives));
			((BufferSerializer<bool>*)(&serializer))->SerializeValue<bool>(ref ShouldDestroyDeadBody, default(ForPrimitives));
			((BufferSerializer<bool>*)(&serializer))->SerializeValue<bool>(ref ResetBodyBlood, default(ForPrimitives));
		}
	}
	public struct TeleportLethalBotNetworkSerializable : INetworkSerializable
	{
		public Vector3 Pos;

		public bool? SetOutside;

		public bool WithRotation;

		public float Rot;

		public bool AllowInteractTrigger;

		public NetworkObjectReference? TargetEntrance;

		public bool SkipNavMeshCheck;

		public TeleportLethalBotNetworkSerializable()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			Pos = default(Vector3);
			SetOutside = null;
			WithRotation = false;
			Rot = 0f;
			AllowInteractTrigger = false;
			TargetEntrance = null;
			SkipNavMeshCheck = false;
		}

		public unsafe void NetworkSerialize<T>(BufferSerializer<T> serializer) where T : IReaderWriter
		{
			//IL_000d: 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_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			serializer.SerializeValue(ref Pos);
			LethalBotNetworkSerializer.SerializeNullable<bool, T>(serializer, ref SetOutside);
			((BufferSerializer<bool>*)(&serializer))->SerializeValue<bool>(ref WithRotation, default(ForPrimitives));
			((BufferSerializer<float>*)(&serializer))->SerializeValue<float>(ref Rot, default(ForPrimitives));
			((BufferSerializer<bool>*)(&serializer))->SerializeValue<bool>(ref AllowInteractTrigger, default(ForPrimitives));
			LethalBotNetworkSerializer.SerializeNullable<T>(serializer, ref TargetEntrance);
			((BufferSerializer<bool>*)(&serializer))->SerializeValue<bool>(ref SkipNavMeshCheck, default(ForPrimitives));
		}
	}
}
namespace LethalBots.Managers
{
	public class AudioManager : MonoBehaviour
	{
		[CompilerGenerated]
		private sealed class <LoadAudioAndPlay>d__13 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public AudioManager <>4__this;

			public string uri;

			public LethalBotVoice lethalBotVoice;

			private string <sanitizedUri>5__2;

			private UnityWebRequest <www>5__3;

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

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

			[DebuggerHidden]
			public <LoadAudioAndPlay>d__13(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

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

			private bool MoveNext()
			{
				//IL_002a: Unknown result type (might be due to invalid IL or missing references)
				//IL_002f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0043: Unknown result type (might be due to invalid IL or missing references)
				//IL_009d: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a3: Invalid comparison between Unknown and I4
				//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b1: Invalid comparison between Unknown and I4
				try
				{
					int num = <>1__state;
					AudioManager audioManager = <>4__this;
					switch (num)
					{
					default:
						return false;
					case 0:
					{
						<>1__state = -1;
						AudioType audioType = audioManager.GetAudioType(uri);
						<sanitizedUri>5__2 = uri;
						<www>5__3 = UnityWebRequestMultimedia.GetAudioClip(<sanitizedUri>5__2, audioType);
						<>1__state = -3;
						<>2__current = <www>5__3.SendWebRequest();
						<>1__state = 1;
						return true;
					}
					case 1:
						<>1__state = -3;
						Plugin.LogDebug($"Loading audio file at {<www>5__3.uri}");
						if ((int)<www>5__3.result == 2 || (int)<www>5__3.result == 3)
						{
							lethalBotVoice.ResetAboutToTalk();
							Plugin.LogError("Error while loading audio file at " + uri + " : " + <www>5__3.error + " \n SanitizedUri: " + <sanitizedUri>5__2);
						}
						else
						{
							Plugin.LogInfo("Loaded audio file at " + uri + " \n SanitizedUri: " + <sanitizedUri>5__2);
							AudioClip content = DownloadHandlerAudioClip.GetContent(<www>5__3);
							audioManager.AddAudioClip(uri, content);
							lethalBotVoice.PlayAudioClip(content);
						}
						<>m__Finally1();
						<www>5__3 = 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 (<www>5__3 != null)
				{
					((IDisposable)<www>5__3).Dispose();
				}
			}

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

		public Dictionary<string, AudioClip?> DictAudioClipsByPath = new Dictionary<string, AudioClip>();

		private const string voicesPath = "Audio\\Voices\\";

		private static readonly string[] SupportedExtentions = new string[3] { ".ogg", ".wav", ".mp3" };

		public static AudioManager Instance { get; private set; } = null;


		private void Awake()
		{
			if ((Object)(object)Instance != (Object)null && (Object)(object)Instance != (Object)(object)this)
			{
				Object.Destroy((Object)(object)((Component)Instance).gameObject);
			}
			Instance = this;
			Plugin.LogDebug("=============== awake audio manager =====================");
			try
			{
				LoadAllVoiceLanguageAudioAssets();
			}
			catch (Exception ex)
			{
				Plugin.LogError("Error while loading voice audios, error : " + ex.Message);
			}
		}

		private void LoadAllVoiceLanguageAudioAssets()
		{
			string text = Utility.CombinePaths(new string[3]
			{
				Paths.ConfigPath,
				"LethalBots",
				"Audio\\Voices\\"
			});
			if (Directory.Exists(text))
			{
				LoadAllPaths(text);
				return;
			}
			text = Path.Combine(Plugin.DirectoryName, "Audio\\Voices\\");
			if (!Directory.Exists(text))
			{
				Directory.CreateDirectory(text);
				Assembly executingAssembly = Assembly.GetExecutingAssembly();
				using Stream stream = executingAssembly.GetManifestResourceStream(executingAssembly.GetName().Name + ".Assets.Audio.Voices.DefaultVoices.zip");
				using ZipArchive source = new ZipArchive(stream, ZipArchiveMode.Read);
				source.ExtractToDirectory(text);
			}
			LoadAllPaths(text);
		}

		private void LoadAllPaths(string folderPath)
		{
			string[] supportedExtentions = SupportedExtentions;
			foreach (string text in supportedExtentions)
			{
				string[] files = Directory.GetFiles(folderPath, "*" + text, SearchOption.AllDirectories);
				string[] array = files;
				foreach (string path in array)
				{
					AddPath(path);
				}
			}
		}

		private void AddPath(string path)
		{
			if (DictAudioClipsByPath == null)
			{
				DictAudioClipsByPath = new Dictionary<string, AudioClip>();
			}
			if (DictAudioClipsByPath.ContainsKey(path))
			{
				Plugin.LogWarning("A path of the same has already been added, path " + path);
			}
			else
			{
				DictAudioClipsByPath.Add(path, null);
			}
		}

		public void SyncPlayAudio(string path, int lethalBotID)
		{
			string text = string.Empty;
			try
			{
				int startIndex = path.IndexOf("Audio\\Voices\\");
				text = path.Substring(startIndex);
			}
			catch (Exception ex)
			{
				Plugin.LogError("Error while loading voice audios, error : " + ex.Message);
			}
			if (string.IsNullOrWhiteSpace(text))
			{
				Plugin.LogError("Problem occured while getting the small path of audio clip, original path : " + path);
			}
			else
			{
				LethalBotManager.Instance.SyncPlayAudioLethalBot(lethalBotID, text);
			}
		}

		public void PlayAudio(string smallPathAudioClip, LethalBotVoice lethalBotVoice)
		{
			string smallPathAudioClip2 = smallPathAudioClip;
			KeyValuePair<string, AudioClip> keyValuePair = DictAudioClipsByPath.FirstOrDefault<KeyValuePair<string, AudioClip>>((KeyValuePair<string, AudioClip> x) => x.Key.Contains(smallPathAudioClip2));
			AudioClip value = keyValuePair.Value;
			if ((Object)(object)value == (Object)null)
			{
				((MonoBehaviour)this).StartCoroutine(LoadAudioAndPlay(keyValuePair.Key, lethalBotVoice));
			}
			else
			{
				lethalBotVoice.PlayAudioClip(value);
			}
			Plugin.LogDebug("New audioClip loaded " + smallPathAudioClip2);
		}

		[IteratorStateMachine(typeof(<LoadAudioAndPlay>d__13))]
		private IEnumerator LoadAudioAndPlay(string uri, LethalBotVoice lethalBotVoice)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <LoadAudioAndPlay>d__13(0)
			{
				<>4__this = this,
				uri = uri,
				lethalBotVoice = lethalBotVoice
			};
		}

		private AudioType GetAudioType(string path)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			AudioType result = (AudioType)0;
			string text = Path.GetExtension(path).ToLower();
			switch (text)
			{
			case ".ogg":
				result = (AudioType)14;
				break;
			case ".wav":
				result = (AudioType)20;
				break;
			case ".mp3":
				result = (AudioType)13;
				break;
			default:
				Plugin.LogWarning("Unsupported audio extension " + text + " for path " + path);
				break;
			}
			return result;
		}

		private void AddAudioClip(string path, AudioClip audioClip)
		{
			if (DictAudioClipsByPath == null)
			{
				DictAudioClipsByPath = new Dictionary<string, AudioClip>();
			}
			if (DictAudioClipsByPath.ContainsKey(path))
			{
				DictAudioClipsByPath[path] = audioClip;
			}
			else
			{
				DictAudioClipsByPath.Add(path, audioClip);
			}
		}
	}
	public static class ChatCommandsManager
	{
		private static readonly List<ChatCommand> globalCommands = new List<ChatCommand>();

		private static readonly Dictionary<Type, List<ChatCommand>> stateCommands = new Dictionary<Type, List<ChatCommand>>();

		private static readonly HashSet<Type> ignoreGlobalCommands = new HashSet<Type>();

		public static void RegisterGlobalCommand(ChatCommand command)
		{
			globalCommands.Add(command);
		}

		public static void RegisterIgnoreDefaultForState<T>() where T : AIState
		{
			ignoreGlobalCommands.Add(typeof(T));
		}

		public static void RegisterCommandForState<T>(ChatCommand command) where T : AIState
		{
			Type typeFromHandle = typeof(T);
			if (!stateCommands.TryGetValue(typeFromHandle, out List<ChatCommand> value))
			{
				value = new List<ChatCommand>();
				stateCommands[typeFromHandle] = value;
			}
			value.Add(command);
		}

		public static ChatCommand[] GetAllRegisteredChatCommands()
		{
			List<ChatCommand> list = new List<ChatCommand>(globalCommands);
			foreach (KeyValuePair<Type, List<ChatCommand>> stateCommand in stateCommands)
			{
				list.AddRange(stateCommand.Value);
			}
			return list.ToArray();
		}

		public static string[] GetAllRegisteredChatCommandKeywords()
		{
			HashSet<string> hashSet = new HashSet<string>();
			ChatCommand[] allRegisteredChatCommands = GetAllRegisteredChatCommands();
			ChatCommand[] array = allRegisteredChatCommands;
			foreach (ChatCommand chatCommand in array)
			{
				string[] keywords = chatCommand.Keywords;
				foreach (string item in keywords)
				{
					hashSet.Add(item);
				}
			}
			return hashSet.ToArray();
		}

		internal static void RemoveAllChatCommands()
		{
			globalCommands.Clear();
			stateCommands.Clear();
			ignoreGlobalCommands.Clear();
		}

		public static bool OnPlayerChatMessageReceived(AIState state, string message, PlayerControllerB playerWhoSentMessage, bool isVoice)
		{
			Type type = state.GetType();
			LethalBotAI ai = state.ai;
			if (stateCommands.TryGetValue(type, out List<ChatCommand> value))
			{
				foreach (ChatCommand item in value)
				{
					string[] keywords = item.Keywords;
					foreach (string value2 in keywords)
					{
						if (message.Contains(value2) && item.Execute(state, ai, playerWhoSentMessage, message, isVoice))
						{
							return true;
						}
					}
				}
			}
			if (ignoreGlobalCommands.Contains(type))
			{
				return false;
			}
			foreach (ChatCommand globalCommand in globalCommands)
			{
				string[] keywords2 = globalCommand.Keywords;
				foreach (string value3 in keywords2)
				{
					if (message.Contains(value3) && globalCommand.Execute(state, ai, playerWhoSentMessage, message, isVoice))
					{
						return true;
					}
				}
			}
			return false;
		}
	}
	public class GroupManager : NetworkBehaviour
	{
		public const int INVALID_GROUP_INDEX = -1;

		private const int DEFAULT_GROUP_INDEX = 0;

		public NetworkList<LethalBotGroupMemberNetworkSerializable> LethalBotGroups = new NetworkList<LethalBotGroupMemberNetworkSerializable>((IEnumerable<LethalBotGroupMemberNetworkSerializable>)null, (NetworkVariableReadPermission)0, (NetworkVariableWritePermission)0);

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

		private readonly Dictionary<int, HashSet<ulong>> groupMembers = new Dictionary<int, HashSet<ulong>>();

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

		private int nextGroupId;

		public static GroupManager Instance { get; private set; }

		private void Awake()
		{
			if ((Object)(object)Instance != (Object)null && (Object)(object)Instance != (Object)(object)this)
			{
				if (((NetworkBehaviour)Instance).IsSpawned && ((NetworkBehaviour)Instance).IsServer)
				{
					((NetworkBehaviour)Instance).NetworkObject.Despawn(true);
				}
				else
				{
					Object.Destroy((Object)(object)((Component)Instance).gameObject);
				}
			}
			Instance = this;
		}

		public override void OnNetworkSpawn()
		{
			((NetworkBehaviour)this).OnNetworkSpawn();
			LethalBotGroups.OnListChanged += OnGroupListChanged;
			if (!((NetworkBehaviour)this).NetworkManager.IsServer)
			{
				if ((Object)(object)Instance != (Object)null && (Object)(object)Instance != (Object)(object)this)
				{
					Object.Destroy((Object)(object)((Component)Instance).gameObject);
				}
				Instance = this;
			}
		}

		public override void OnNetworkDespawn()
		{
			((NetworkBehaviour)this).OnNetworkDespawn();
			LethalBotGroups.OnListChanged -= OnGroupListChanged;
		}

		private int CreateGroup(PlayerControllerB leader)
		{
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			if (!((NetworkBehaviour)this).IsServer)
			{
				return -1;
			}
			RemoveFromCurrentGroup(leader);
			int num = nextGroupId++;
			LethalBotGroups.Add(new LethalBotGroupMemberNetworkSerializable
			{
				GroupId = num,
				Member = NetworkBehaviourReference.op_Implicit((NetworkBehaviour)(object)leader),
				IsLeader = true
			});
			return num;
		}

		public void CreateGroupAndSync(PlayerControllerB leader)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			if (((NetworkBehaviour)this).IsServer)
			{
				CreateGroup(leader);
			}
			else
			{
				CreateGroupServerRpc(NetworkBehaviourReference.op_Implicit((NetworkBehaviour)(object)leader));
			}
		}

		[ServerRpc(RequireOwnership = false)]
		private void CreateGroupServerRpc(NetworkBehaviourReference player)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				ServerRpcParams val = default(ServerRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(1754286140u, val, (RpcDelivery)0);
				((FastBufferWriter)(ref val2)).WriteValueSafe<NetworkBehaviourReference>(ref player, default(ForNetworkSerializable));
				((NetworkBehaviour)this).__endSendServerRpc(ref val2, 1754286140u, val, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				PlayerControllerB leader = default(PlayerControllerB);
				if (((NetworkBehaviourReference)(ref player)).TryGet<PlayerControllerB>(ref leader, (NetworkManager)null))
				{
					CreateGroup(leader);
				}
			}
		}

		private void AddToGroup(int groupId, PlayerControllerB member)
		{
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			if (((NetworkBehaviour)this).IsServer && DoesGroupExist(groupId) && !IsPlayerInGroup(member, groupId))
			{
				RemoveFromCurrentGroup(member);
				LethalBotGroups.Add(new LethalBotGroupMemberNetworkSerializable
				{
					GroupId = groupId,
					Member = NetworkBehaviourReference.op_Implicit((NetworkBehaviour)(object)member),
					IsLeader = false
				});
			}
		}

		public void AddToGroupAndSync(int groupId, PlayerControllerB member)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			if (((NetworkBehaviour)this).IsServer)
			{
				AddToGroup(groupId, member);
			}
			else
			{
				AddToGroupServerRpc(groupId, NetworkBehaviourReference.op_Implicit((NetworkBehaviour)(object)member));
			}
		}

		[ServerRpc(RequireOwnership = false)]
		private void AddToGroupServerRpc(int groupId, NetworkBehaviourReference player)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				ServerRpcParams val = default(ServerRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(2634232810u, val, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val2, groupId);
				((FastBufferWriter)(ref val2)).WriteValueSafe<NetworkBehaviourReference>(ref player, default(ForNetworkSerializable));
				((NetworkBehaviour)this).__endSendServerRpc(ref val2, 2634232810u, val, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				PlayerControllerB member = default(PlayerControllerB);
				if (((NetworkBehaviourReference)(ref player)).TryGet<PlayerControllerB>(ref member, (NetworkManager)null))
				{
					AddToGroup(groupId, member);
				}
			}
		}

		public void CreateOrJoinGroupAndSync(PlayerControllerB player)
		{
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			LethalBotAI lethalBotAI = LethalBotManager.Instance.GetLethalBotAI(player);
			if ((Object)(object)lethalBotAI == (Object)null)
			{
				CreateGroupAndSync(player);
			}
			else if (((NetworkBehaviour)this).IsServer)
			{
				if (DoesInternalGroupExist(lethalBotAI, out var groupID))
				{
					AddToGroup(groupID, player);
				}
				else
				{
					CreateGroup(player);
				}
			}
			else
			{
				CreateOrJoinGroupServerRpc(NetworkBehaviourReference.op_Implicit((NetworkBehaviour)(object)player));
			}
		}

		[ServerRpc(RequireOwnership = false)]
		private void CreateOrJoinGroupServerRpc(NetworkBehaviourReference player)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				ServerRpcParams val = default(ServerRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(264295010u, val, (RpcDelivery)0);
				((FastBufferWriter)(ref val2)).WriteValueSafe<NetworkBehaviourReference>(ref player, default(ForNetworkSerializable));
				((NetworkBehaviour)this).__endSendServerRpc(ref val2, 264295010u, val, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				PlayerControllerB player2 = default(PlayerControllerB);
				if (((NetworkBehaviourReference)(ref player)).TryGet<PlayerControllerB>(ref player2, (NetworkManager)null))
				{
					CreateOrJoinGroupAndSync(player2);
				}
			}
		}

		public void CreateOrJoinGroupWithMembersAndSync(PlayerControllerB leader, PlayerControllerB[] members, bool forceNewGroup = false)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			if (((NetworkBehaviour)this).IsServer)
			{
				CreateOrJoinGroupWithMembers(leader, members, forceNewGroup);
				return;
			}
			CreateOrJoinGroupWithMembersServerRpc(NetworkBehaviourReference.op_Implicit((NetworkBehaviour)(object)leader), ((IEnumerable<PlayerControllerB>)members).Select((Func<PlayerControllerB, NetworkBehaviourReference>)((PlayerControllerB m) => new NetworkBehaviourReference((NetworkBehaviour)(object)m))).ToArray(), forceNewGroup);
		}

		private void CreateOrJoinGroupWithMembers(PlayerControllerB leader, PlayerControllerB[] members, bool forceNewGroup = false)
		{
			if (!((NetworkBehaviour)this).IsServer)
			{
				return;
			}
			if (forceNewGroup || !IsPlayerGroupLeader(leader, out var groupId) || groupId == -1)
			{
				groupId = CreateGroup(leader);
			}
			if (groupId != -1)
			{
				foreach (PlayerControllerB member in members)
				{
					AddToGroup(groupId, member);
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		private void CreateOrJoinGroupWithMembersServerRpc(NetworkBehaviourReference player, NetworkBehaviourReference[] players, bool forceNewGroup = false)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_010d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0117: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0142: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0161: Unknown result type (might be due to invalid IL or missing references)
			//IL_0166: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				ServerRpcParams val = default(ServerRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(2990711509u, val, (RpcDelivery)0);
				((FastBufferWriter)(ref val2)).WriteValueSafe<NetworkBehaviourReference>(ref player, default(ForNetworkSerializable));
				bool flag = players != null;
				((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				if (flag)
				{
					((FastBufferWriter)(ref val2)).WriteValueSafe<NetworkBehaviourReference>(players, default(ForNetworkSerializable));
				}
				((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref forceNewGroup, default(ForPrimitives));
				((NetworkBehaviour)this).__endSendServerRpc(ref val2, 2990711509u, val, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage != 1 || (!networkManager.IsServer && !networkManager.IsHost))
			{
				return;
			}
			base.__rpc_exec_stage = (__RpcExecStage)0;
			PlayerControllerB leader = default(PlayerControllerB);
			if (!((NetworkBehaviourReference)(ref player)).TryGet<PlayerControllerB>(ref leader, (NetworkManager)null))
			{
				return;
			}
			HashSet<PlayerControllerB> hashSet = new HashSet<PlayerControllerB>();
			PlayerControllerB item = default(PlayerControllerB);
			for (int i = 0; i < players.Length; i++)
			{
				NetworkBehaviourReference val3 = players[i];
				if (((NetworkBehaviourReference)(ref val3)).TryGet<PlayerControllerB>(ref item, (NetworkManager)null))
				{
					hashSet.Add(item);
				}
			}
			CreateOrJoinGroupWithMembers(leader, hashSet.ToArray(), forceNewGroup);
		}

		private void RemoveFromCurrentGroup(PlayerControllerB member)
		{
			if (!((NetworkBehaviour)this).IsServer)
			{
				return;
			}
			PlayerControllerB val = default(PlayerControllerB);
			for (int num = LethalBotGroups.Count - 1; num >= 0; num--)
			{
				LethalBotGroupMemberNetworkSerializable lethalBotGroupMemberNetworkSerializable = LethalBotGroups[num];
				if (((NetworkBehaviourReference)(ref lethalBotGroupMemberNetworkSerializable.Member)).TryGet<PlayerControllerB>(ref val, (NetworkManager)null) && (Object)(object)val == (Object)(object)member)
				{
					LethalBotGroups.RemoveAt(num);
					if (lethalBotGroupMemberNetworkSerializable.IsLeader)
					{
						HandleLeaderRemoval(lethalBotGroupMemberNetworkSerializable.GroupId);
					}
				}
			}
		}

		public void RemoveFromCurrentGroupAndSync(PlayerControllerB member)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			if (((NetworkBehaviour)this).IsServer)
			{
				RemoveFromCurrentGroup(member);
			}
			else
			{
				RemoveFromCurrentGroupServerRpc(NetworkBehaviourReference.op_Implicit((NetworkBehaviour)(object)member));
			}
		}

		[ServerRpc(RequireOwnership = false)]
		private void RemoveFromCurrentGroupServerRpc(NetworkBehaviourReference player)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				ServerRpcParams val = default(ServerRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(1685315367u, val, (RpcDelivery)0);
				((FastBufferWriter)(ref val2)).WriteValueSafe<NetworkBehaviourReference>(ref player, default(ForNetworkSerializable));
				((NetworkBehaviour)this).__endSendServerRpc(ref val2, 1685315367u, val, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				PlayerControllerB member = default(PlayerControllerB);
				if (((NetworkBehaviourReference)(ref player)).TryGet<PlayerControllerB>(ref member, (NetworkManager)null))
				{
					RemoveFromCurrentGroup(member);
				}
			}
		}

		public bool IsPlayerInGroup(PlayerControllerB player)
		{
			return GetGroupId(player) != -1;
		}

		public bool IsPlayerInGroup(PlayerControllerB player, int groupID)
		{
			return GetGroupId(player) == groupID;
		}

		public bool IsPlayerGroupLeader(PlayerControllerB player, out int groupId)
		{
			groupId = GetGroupId(player);
			if (groupId == -1)
			{
				return false;
			}
			if (groupLeaders.TryGetValue(groupId, out var value))
			{
				return value == ((NetworkBehaviour)player).NetworkObjectId;
			}
			return false;
		}

		public bool ArePlayersInSameGroup(PlayerControllerB a, PlayerControllerB b)
		{
			int groupId = GetGroupId(a);
			int groupId2 = GetGroupId(b);
			if (groupId != -1)
			{
				return groupId == groupId2;
			}
			return false;
		}

		public int GetGroupId(PlayerControllerB player)
		{
			if (memberToGroup.TryGetValue(((NetworkBehaviour)player).NetworkObjectId, out var value))
			{
				return value;
			}
			return -1;
		}

		public bool DoesGroupExist(int groupId)
		{
			return groupMembers.ContainsKey(groupId);
		}

		public IEnumerable<int> GetAllGroups()
		{
			return groupMembers.Keys;
		}

		public int GetGroupSize(int groupId)
		{
			if (groupMembers.TryGetValue(groupId, out HashSet<ulong> value))
			{
				return value.Count;
			}
			return 0;
		}

		public List<PlayerControllerB> GetGroupMembers(int groupId)
		{
			List<PlayerControllerB> list = new List<PlayerControllerB>();
			if (!groupMembers.TryGetValue(groupId, out HashSet<ulong> value))
			{
				return list;
			}
			Dictionary<ulong, NetworkObject> spawnedObjects = ((NetworkBehaviour)this).NetworkManager.SpawnManager.SpawnedObjects;
			PlayerControllerB item = default(PlayerControllerB);
			foreach (ulong item2 in value)
			{
				if (spawnedObjects.TryGetValue(item2, out var value2) && ((Component)value2).TryGetComponent<PlayerControllerB>(ref item))
				{
					list.Add(item);
				}
			}
			return list;
		}

		public List<PlayerControllerB> GetOtherGroupMembers(PlayerControllerB player)
		{
			int groupId = GetGroupId(player);
			if (groupId == -1)
			{
				return new List<PlayerControllerB>();
			}
			List<PlayerControllerB> list = GetGroupMembers(groupId);
			list.Remove(player);
			return list;
		}

		public PlayerControllerB? GetGroupLeader(int groupId)
		{
			if (!groupLeaders.TryGetValue(groupId, out var value))
			{
				return null;
			}
			PlayerControllerB result = default(PlayerControllerB);
			if (((NetworkBehaviour)this).NetworkManager.SpawnManager.SpawnedObjects.TryGetValue(value, out var value2) && ((Component)value2).TryGetComponent<PlayerControllerB>(ref result))
			{
				return result;
			}
			return null;
		}

		public bool DoesGroupHaveScrap(int groupId)
		{
			List<PlayerControllerB> list = GetGroupMembers(groupId);
			foreach (PlayerControllerB item in list)
			{
				if ((Object)(object)item == (Object)null)
				{
					continue;
				}
				LethalBotAI lethalBotAI = LethalBotManager.Instance.GetLethalBotAI(item);
				if ((Object)(object)lethalBotAI != (Object)null)
				{
					if (lethalBotAI.HasScrapInInventory())
					{
						return true;
					}
					continue;
				}
				GrabbableObject itemOnlySlot = item.ItemOnlySlot;
				if ((Object)(object)itemOnlySlot != (Object)null && LethalBotAI.IsItemScrap(itemOnlySlot))
				{
					return true;
				}
				GrabbableObject[] itemSlots = item.ItemSlots;
				foreach (GrabbableObject val in itemSlots)
				{
					if ((Object)(object)val != (Object)null && LethalBotAI.IsItemScrap(val))
					{
						return true;
					}
				}
			}
			return false;
		}

		public PlayerControllerB? GetClosestGroupMember(PlayerControllerB player, int? playerGroupId = null)
		{
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			int num = playerGroupId ?? GetGroupId(player);
			if (num == -1 || GetGroupSize(num) <= 1)
			{
				return null;
			}
			List<PlayerControllerB> list = GetGroupMembers(num);
			Vector3 position = ((Component)player).transform.position;
			PlayerControllerB result = null;
			float num2 = float.MaxValue;
			foreach (PlayerControllerB item in list)
			{
				if (!((Object)(object)item == (Object)(object)player))
				{
					Vector3 val = ((Component)item).transform.position - position;
					float sqrMagnitude = ((Vector3)(ref val)).sqrMagnitude;
					if (sqrMagnitude < num2)
					{
						num2 = sqrMagnitude;
						result = item;
					}
				}
			}
			return result;
		}

		public Vector3 GetGroupCenter(PlayerControllerB player, int? groupId = null)
		{
			//IL_002e: 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)
			int num = groupId ?? GetGroupId(player);
			if (num == -1)
			{
				return ((Component)player).transform.position;
			}
			return GetGroupCenter(num);
		}

		public Vector3 GetGroupCenter(int groupId)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			if (!groupMembers.TryGetValue(groupId, out HashSet<ulong> value) || value.Count == 0)
			{
				return Vector3.zero;
			}
			Vector3 val = Vector3.zero;
			int num = 0;
			Dictionary<ulong, NetworkObject> spawnedObjects = ((NetworkBehaviour)this).NetworkManager.SpawnManager.SpawnedObjects;
			PlayerControllerB val2 = default(PlayerControllerB);
			foreach (ulong item in value)
			{
				if (spawnedObjects.TryGetValue(item, out var value2) && ((Component)value2).TryGetComponent<PlayerControllerB>(ref val2))
				{
					val += ((Component)val2).transform.position;
					num++;
				}
			}
			if (num <= 0)
			{
				return Vector3.zero;
			}
			return val / (float)num;
		}

		public PlayerControllerB? GetFurthestMemberFromCenter(int groupId)
		{
			//IL_001d: 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_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			if (!groupMembers.TryGetValue(groupId, out HashSet<ulong> value) || value.Count <= 1)
			{
				return null;
			}
			Vector3 groupCenter = GetGroupCenter(groupId);
			PlayerControllerB result = null;
			float num = 0f;
			Dictionary<ulong, NetworkObject> spawnedObjects = ((NetworkBehaviour)this).NetworkManager.SpawnManager.SpawnedObjects;
			PlayerControllerB val = default(PlayerControllerB);
			foreach (ulong item in value)
			{
				if (spawnedObjects.TryGetValue(item, out var value2) && ((Component)value2).TryGetComponent<PlayerControllerB>(ref val))
				{
					Vector3 val2 = ((Component)val).transform.position - groupCenter;
					float sqrMagnitude = ((Vector3)(ref val2)).sqrMagnitude;
					if (sqrMagnitude > num)
					{
						num = sqrMagnitude;
						result = val;
					}
				}
			}
			return result;
		}

		public void ResetAndRemoveAllGroups()
		{
			if (((NetworkBehaviour)this).IsServer)
			{
				nextGroupId = 0;
				memberToGroup.Clear();
				groupMembers.Clear();
				groupLeaders.Clear();
				LethalBotGroups.Clear();
			}
		}

		public bool DoesInternalGroupExist(LethalBotAI lethalBotAI, out int groupID)
		{
			groupID = -1;
			if ((Object)(object)lethalBotAI == (Object)null)
			{
				return false;
			}
			int groupID2 = lethalBotAI.LethalBotIdentity.GroupID;
			LethalBotAI[] lethalBotAIs = LethalBotManager.Instance.GetLethalBotAIs();
			LethalBotAI[] array = lethalBotAIs;
			foreach (LethalBotAI lethalBotAI2 in array)
			{
				if (!((Object)(object)lethalBotAI2 == (Object)null) && !((Object)(object)lethalBotAI2 == (Object)(object)lethalBotAI))
				{
					PlayerControllerB val = lethalBotAI?.NpcController?.Npc;
					if (!((Object)(object)val == (Object)null) && val.isPlayerControlled && !val.isPlayerDead && lethalBotAI2.LethalBotIdentity.GroupID == groupID2 && IsPlayerGroupLeader(lethalBotAI2.NpcController.Npc, out groupID))
					{
						return true;
					}
				}
			}
			return false;
		}

		private void HandleLeaderRemoval(int groupId)
		{
			LethalBotGroupMemberNetworkSerializable? lethalBotGroupMemberNetworkSerializable = null;
			int num = -1;
			PlayerControllerB player = default(PlayerControllerB);
			for (int i = 0; i < LethalBotGroups.Count; i++)
			{
				LethalBotGroupMemberNetworkSerializable value = LethalBotGroups[i];
				if (value.GroupId != groupId || value.IsLeader || !((NetworkBehaviourReference)(ref value.Member)).TryGet<PlayerControllerB>(ref player, (NetworkManager)null))
				{
					continue;
				}
				bool flag = !LethalBotManager.Instance.IsPlayerLethalBot(player);
				if (lethalBotGroupMemberNetworkSerializable == null || flag)
				{
					num = i;
					lethalBotGroupMemberNetworkSerializable = value;
					if (flag)
					{
						break;
					}
				}
			}
			if (lethalBotGroupMemberNetworkSerializable != null)
			{
				LethalBotGroupMemberNetworkSerializable value2 = lethalBotGroupMemberNetworkSerializable.Value;
				value2.IsLeader = true;
				LethalBotGroups[num] = value2;
			}
		}

		private void OnGroupListChanged(NetworkListEvent<LethalBotGroupMemberNetworkSerializable> change)
		{
			RebuildLookups();
		}

		private void RebuildLookups()
		{
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			memberToGroup.Clear();
			groupMembers.Clear();
			groupLeaders.Clear();
			NetworkBehaviour val = default(NetworkBehaviour);
			foreach (LethalBotGroupMemberNetworkSerializable lethalBotGroup in LethalBotGroups)
			{
				NetworkBehaviourReference member = lethalBotGroup.Member;
				if (((NetworkBehaviourReference)(ref member)).TryGet(ref val, (NetworkManager)null))
				{
					ulong networkObjectId = val.NetworkObjectId;
					memberToGroup[networkObjectId] = lethalBotGroup.GroupId;
					if (lethalBotGroup.IsLeader)
					{
						groupLeaders[lethalBotGroup.GroupId] = networkObjectId;
					}
					if (!groupMembers.TryGetValue(lethalBotGroup.GroupId, out HashSet<ulong> value))
					{
						value = new HashSet<ulong>();
						groupMembers[lethalBotGroup.GroupId] = value;
					}
					value.Add(networkObjectId);
				}
			}
		}

		protected override void __initializeVariables()
		{
			if (LethalBotGroups == null)
			{
				throw new Exception("GroupManager.LethalBotGroups cannot be null. All NetworkVariableBase instances must be initialized.");
			}
			((NetworkVariableBase)LethalBotGroups).Initialize((NetworkBehaviour)(object)this);
			((NetworkBehaviour)this).__nameNetworkVariable((NetworkVariableBase)(object)LethalBotGroups, "LethalBotGroups");
			base.NetworkVariableFields.Add((NetworkVariableBase)(object)LethalBotGroups);
			((NetworkBehaviour)this).__initializeVariables();
		}

		protected override void __initializeRpcs()
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Expected O, but got Unknown
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Expected O, but got Unknown
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Expected O, but got Unknown
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Expected O, but got Unknown
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Expected O, but got Unknown
			((NetworkBehaviour)this).__registerRpc(1754286140u, new RpcReceiveHandler(__rpc_handler_1754286140), "CreateGroupServerRpc");
			((NetworkBehaviour)this).__registerRpc(2634232810u, new RpcReceiveHandler(__rpc_handler_2634232810), "AddToGroupServerRpc");
			((NetworkBehaviour)this).__registerRpc(264295010u, new RpcReceiveHandler(__rpc_handler_264295010), "CreateOrJoinGroupServerRpc");
			((NetworkBehaviour)this).__registerRpc(2990711509u, new RpcReceiveHandler(__rpc_handler_2990711509), "CreateOrJoinGroupWithMembersServerRpc");
			((NetworkBehaviour)this).__registerRpc(1685315367u, new RpcReceiveHandler(__rpc_handler_1685315367), "RemoveFromCurrentGroupServerRpc");
			((NetworkBehaviour)this).__initializeRpcs();
		}

		private static void __rpc_handler_1754286140(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				NetworkBehaviourReference player = default(NetworkBehaviourReference);
				((FastBufferReader)(ref reader)).ReadValueSafe<NetworkBehaviourReference>(ref player, default(ForNetworkSerializable));
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((GroupManager)(object)target).CreateGroupServerRpc(player);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2634232810(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int groupId = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref groupId);
				NetworkBehaviourReference player = default(NetworkBehaviourReference);
				((FastBufferReader)(ref reader)).ReadValueSafe<NetworkBehaviourReference>(ref player, default(ForNetworkSerializable));
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((GroupManager)(object)target).AddToGroupServerRpc(groupId, player);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_264295010(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				NetworkBehaviourReference player = default(NetworkBehaviourReference);
				((FastBufferReader)(ref reader)).ReadValueSafe<NetworkBehaviourReference>(ref player, default(ForNetworkSerializable));
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((GroupManager)(object)target).CreateOrJoinGroupServerRpc(player);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2990711509(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				NetworkBehaviourReference player = default(NetworkBehaviourReference);
				((FastBufferReader)(ref reader)).ReadValueSafe<NetworkBehaviourReference>(ref player, default(ForNetworkSerializable));
				bool flag = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
				NetworkBehaviourReference[] players = null;
				if (flag)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe<NetworkBehaviourReference>(ref players, default(ForNetworkSerializable));
				}
				bool forceNewGroup = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref forceNewGroup, default(ForPrimitives));
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((GroupManager)(object)target).CreateOrJoinGroupWithMembersServerRpc(player, players, forceNewGroup);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1685315367(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				NetworkBehaviourReference player = default(NetworkBehaviourReference);
				((FastBufferReader)(ref reader)).ReadValueSafe<NetworkBehaviourReference>(ref player, default(ForNetworkSerializable));
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((GroupManager)(object)target).RemoveFromCurrentGroupServerRpc(player);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		protected internal override string __getTypeName()
		{
			return "GroupManager";
		}
	}
	public class IdentityManager : MonoBehaviour
	{
		public LethalBotIdentity[] LethalBotIdentities;

		private ConfigIdentity[] configIdentities;

		public static IdentityManager Instance { get; private set; }

		public LethalBotIdentity? this[int index]
		{
			get
			{
				if (index < 0 || index >= LethalBotIdentities.Length)
				{
					throw new IndexOutOfRangeException();
				}
				return LethalBotIdentities[index];
			}
		}

		private void Awake()
		{
			if ((Object)(object)Instance != (Object)null && (Object)(object)Instance != (Object)(object)this)
			{
				Object.Destroy((Object)(object)((Component)Instance).gameObject);
			}
			Instance = this;
			Plugin.LogDebug("=============== awake IdentityManager =====================");
		}

		private void Update()
		{
			if (LethalBotIdentities == null)
			{
				return;
			}
			for (int i = 0; i < LethalBotIdentities.Length; i++)
			{
				LethalBotIdentity lethalBotIdentity = LethalBotIdentities[i];
				if (lethalBotIdentity != null && lethalBotIdentity.Voice != null)
				{
					lethalBotIdentity.Voice.ReduceCooldown(Time.deltaTime);
				}
			}
		}

		public void InitIdentities(ConfigIdentity[] configIdentities)
		{
			Plugin.LogDebug($"InitIdentities, nbIdentities {configIdentities.Length}");
			LethalBotIdentities = new LethalBotIdentity[configIdentities.Length];
			this.configIdentities = configIdentities;
			for (int i = 0; i < configIdentities.Length; i++)
			{
				LethalBotIdentities[i] = InitNewIdentity(i);
			}
		}

		private LethalBotIdentity InitNewIdentity(int idIdentity)
		{
			ConfigIdentity configIdentity;
			string name;
			if (idIdentity >= configIdentities.Length)
			{
				configIdentity = ConfigConst.DEFAULT_CONFIG_IDENTITY;
				name = string.Format(configIdentity.name, idIdentity);
				configIdentity.voicePitch = Random.Range(0.8f, 1.2f);
			}
			else
			{
				configIdentity = configIdentities[idIdentity];
				name = configIdentity.name;
			}
			int? suitID = null;
			EnumOptionSuitConfig enumOptionSuitConfig;
			if (!Enum.IsDefined(typeof(EnumOptionSuitConfig), configIdentity.suitConfigOption))
			{
				Plugin.LogWarning($"Could not get option for bot suit config in config file, value {configIdentity.suitConfigOption}, for {configIdentity.name}, now using random suit.");
				enumOptionSuitConfig = EnumOptionSuitConfig.Random;
			}
			else
			{
				enumOptionSuitConfig = (EnumOptionSuitConfig)configIdentity.suitConfigOption;
			}
			switch (enumOptionSuitConfig)
			{
			case EnumOptionSuitConfig.Fixed:
				suitID = configIdentity.suitID;
				break;
			case EnumOptionSuitConfig.Random:
				suitID = null;
				break;
			}
			EnumDefaultAIState defaultAIState;
			if (!Enum.IsDefined(typeof(EnumDefaultAIState), configIdentity.defaultAIState))
			{
				Plugin.LogWarning($"Could not get option bot default AI state config in config file, value {configIdentity.defaultAIState}, for {configIdentity.name}, now using default value.");
				defaultAIState = EnumDefaultAIState.Dynamic;
			}
			else
			{
				defaultAIState = (EnumDefaultAIState)configIdentity.defaultAIState;
			}
			int? num = configIdentity.groupID;
			if (!num.HasValue)
			{
				Plugin.LogWarning("Could not get internal group id for bot, for " + configIdentity.name + ", now using default value.");
				num = -1;
			}
			LethalBotVoice voice = new LethalBotVoice(configIdentity.voiceFolder, configIdentity.volume, configIdentity.voicePitch);
			LethalBotLoadout lethalBotLoadoutWithName = LoadoutManager.Instance.GetLethalBotLoadoutWithName(configIdentity.loadoutName ?? string.Empty);
			string text = configIdentity.moreCompanyCosmetics;
			if (string.IsNullOrWhiteSpace(text))
			{
				text = string.Empty;
			}
			return new LethalBotIdentity(idIdentity, name, suitID, voice, lethalBotLoadoutWithName, text, num.Value, defaultAIState);
		}

		public string[] GetIdentitiesNamesLowerCaseWithoutSpace()
		{
			if (LethalBotIdentities == null)
			{
				return new string[0];
			}
			return LethalBotIdentities.Select((LethalBotIdentity x) => string.Join(' ', x.Name).ToLowerInvariant()).ToArray();
		}

		public LethalBotIdentity? GetIdentiyFromIndex(int index)
		{
			if (index < 0 || index > LethalBotIdentities.Length)
			{
				return null;
			}
			return LethalBotIdentities[index];
		}

		public int GetNewIdentityToSpawn()
		{
			int num = ((!SyncedEntry<bool>.op_Implicit(Plugin.Config.SpawnIdentitiesRandomly)) ? GetNextAvailableIdentityIndex() : GetRandomAvailableIdentityIndex());
			if (num == -1)
			{
				ExpandWithNewDefaultIdentities(1);
				return LethalBotIdentities.Length - 1;
			}
			return num;
		}

		public int GetRandomAvailableIdentityIndex()
		{
			LethalBotIdentity[] array = LethalBotIdentities.FilterAvailable().ToArray();
			if (array.Length == 0)
			{
				return -1;
			}
			Random random = new Random();
			int num = random.Next(0, array.Length);
			return array[num].IdIdentity;
		}

		public int GetNextAvailableIdentityIndex()
		{
			LethalBotIdentity[] array = LethalBotIdentities.FilterAvailable().ToArray();
			if (array.Length == 0)
			{
				return -1;
			}
			return array[0].IdIdentity;
		}

		public void ExpandWithNewDefaultIdentities(int numberToAdd)
		{
			Array.Resize(ref LethalBotIdentities, LethalBotIdentities.Length + numberToAdd);
			for (int i = LethalBotIdentities.Length - numberToAdd; i < LethalBotIdentities.Length; i++)
			{
				LethalBotIdentities[i] = InitNewIdentity(i);
			}
		}

		public LethalBotIdentity? FindIdentityFromBodyName(string bodyName)
		{
			string name = bodyName.Replace("Body of ", "");
			return LethalBotIdentities.FirstOrDefault((LethalBotIdentity x) => x.Name == name);
		}

		public int GetNbIdentitiesAvailable()
		{
			return SyncedEntry<int>.op_Implicit(Plugin.Config.MaxBotsAllowedToSpawn) - LethalBotIdentities.FilterToDropOrSpawned().Count();
		}

		public int GetNbIdentitiesToDrop()
		{
			return LethalBotIdentities.FilterToDrop().Count();
		}

		public int GetNbIddentitiesToDropOrSpawned()
		{
			return LethalBotIdentities.FilterToDropOrSpawned().Count();
		}

		public int[] GetIdentitiesToDrop()
		{
			if (LethalBotIdentities == null)
			{
				return new int[0];
			}
			return (from x in LethalBotIdentities.FilterToDrop()
				select x.IdIdentity).ToArray();
		}

		public int[] GetIdentitiesAvailable()
		{
			if (LethalBotIdentities == null)
			{
				return new int[0];
			}
			return (from x in LethalBotIdentities.FilterAvailable()
				select x.IdIdentity).ToArray();
		}

		public bool IsAnIdentityToDrop()
		{
			return LethalBotIdentities.FilterToDrop().Any();
		}

		public int GetNbIdentitiesSpawned()
		{
			return LethalBotIdentities.FilterSpawnedAlive().Count();
		}
	}
	internal static class IdentityEnumerableExtension
	{
		public static IEnumerable<LethalBotIdentity> FilterAvailable(this IEnumerable<LethalBotIdentity> enumerable)
		{
			return enumerable.Where((LethalBotIdentity x) => x.Status == EnumStatusIdentity.Available);
		}

		public static IEnumerable<LethalBotIdentity> FilterToDrop(this IEnumerable<LethalBotIdentity> enumerable)
		{
			return enumerable.Where((LethalBotIdentity x) => x.Status == EnumStatusIdentity.ToSpawn);
		}

		public static IEnumerable<LethalBotIdentity> FilterToDropOrSpawned(this IEnumerable<LethalBotIdentity> enumerable)
		{
			return enumerable.Where((LethalBotIdentity x) => x.Status == EnumStatusIdentity.ToSpawn || (x.Status == EnumStatusIdentity.Spawned && x.Alive));
		}

		public static IEnumerable<LethalBotIdentity> FilterSpawnedAlive(this IEnumerable<LethalBotIdentity> enumerable)
		{
			return enumerable.Where((LethalBotIdentity x) => x.Status == EnumStatusIdentity.Spawned && x.Alive);
		}
	}
	public sealed class EndOfGameBotStats
	{
		public LethalBotIdentity Identity { get; set; }

		public PlayerControllerB BotController { get; set; }

		public bool IsAlive { get; set; }

		public EndOfGameBotStats(LethalBotIdentity identity, PlayerControllerB botController, bool isAlive = false)
		{
			Identity = identity ?? throw new ArgumentNullException("identity", "Identity cannot be null.");
			BotController = botController ?? throw new ArgumentNullException("botController", "Bot PlayerControllerB cannot be null.");
			IsAlive = isAlive;
		}
	}
	public class InputManager : MonoBehaviour
	{
		public static InputManager Instance { get; private set; }

		private void Awake()
		{
			if ((Object)(object)Instance != (Object)null && (Object)(object)Instance != (Object)(object)this)
			{
				Object.Destroy((Object)(object)((Component)Instance).gameObject);
			}
			Instance = this;
			AddEventHandlers();
		}

		private void AddEventHandlers()
		{
			Plugin.InputActionsInstance.LeadBot.performed += LeadBot_performed;
			Plugin.InputActionsInstance.DropItem.performed += GiveTakeItem_performed;
			Plugin.InputActionsInstance.ChangeSuitBot.performed += ChangeSuitLethalBot_performed;
		}

		public void RemoveEventHandlers()
		{
			Plugin.InputActionsInstance.LeadBot.performed -= LeadBot_performed;
			Plugin.InputActionsInstance.DropItem.performed -= GiveTakeItem_performed;
			Plugin.InputActionsInstance.ChangeSuitBot.performed -= ChangeSuitLethalBot_performed;
		}

		public string GetKeyAction(InputAction inputAction)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			int num = ((!StartOfRound.Instance.localPlayerUsingController) ? InputActionRebindingExtensions.GetBindingIndex(inputAction, InputBinding.MaskByGroup("KeyboardAndMouse")) : InputActionRebindingExtensions.GetBindingIndex(inputAction, InputBinding.MaskByGroup("Gamepad")));
			return InputActionRebindingExtensions.GetBindingDisplayString(inputAction, num, (DisplayStringOptions)0);
		}

		public void AddLethalBotsControlTip(HUDManager hudManager)
		{
			int num = -1;
			for (int i = 0; i < hudManager.controlTipLines.Length - 1; i++)
			{
				TextMeshProUGUI val = hudManager.controlTipLines[i + 1];
				if ((Object)(object)val != (Object)null && ((Behaviour)val).enabled && string.IsNullOrWhiteSpace(((TMP_Text)val).text))
				{
					num = i;
					break;
				}
			}
			if (num == -1)
			{
				num = hudManager.controlTipLines.Length - 1;
			}
			if (LethalBotManager.Instance.IsLocalPlayerNextToChillLethalBots())
			{
				WriteControlTipLine(hudManager.controlTipLines[num], "Make bots look : [{0}]", GetKeyAction(Plugin.InputActionsInstance.MakeBotLookAtPosition));
			}
		}

		private void WriteControlTipLine(TextMeshProUGUI line, string textToAdd, string keyAction)
		{
			if (!IsStringPresent(((TMP_Text)line).text, textToAdd))
			{
				if (!string.IsNullOrWhiteSpace(((TMP_Text)line).text))
				{
					((TMP_Text)line).text = ((TMP_Text)line).text + "\n";
				}
				((TMP_Text)line).text = ((TMP_Text)line).text + string.Format(textToAdd, keyAction);
			}
		}

		private bool IsStringPresent(string stringCurrent, string stringToAdd)
		{
			string[] array = stringCurrent.Split(new string[2] { "[", "]\n" }, StringSplitOptions.None);
			string[] array2 = array;
			foreach (string text in array2)
			{
				if (!string.IsNullOrWhiteSpace(text) && stringToAdd.Contains(text.Trim()))
				{
					return true;
				}
			}
			return false;
		}

		public void UpdateControlTip()
		{
			string[] array = new string[0];
			if (HUDManager.Instance.controlTipLines != null && HUDManager.Instance.controlTipLines.Length != 0)
			{
				array = HUDManager.Instance.controlTipLines.Select((TextMeshProUGUI i) => ((TMP_Text)i).text).ToArray();
			}
			HUDManager.Instance.ChangeControlTipMultiple(array, false, (Item)null);
		}

		private bool IsPerformedValid(PlayerControllerB localPlayer)
		{
			if (!((NetworkBehaviour)localPlayer).IsOwner || localPlayer.isPlayerDead || !localPlayer.isPlayerControlled)
			{
				return false;
			}
			if (localPlayer.isGrabbingObjectAnimation || localPlayer.isTypingChat || localPlayer.inTerminalMenu || localPlayer.IsInspectingItem)
			{
				return false;
			}
			if ((Object)(object)localPlayer.inAnimationWithEnemy != (Object)null)
			{
				return false;
			}
			if (localPlayer.jetpackControls || localPlayer.disablingJetpackControls)
			{
				return false;
			}
			if (StartOfRound.Instance.suckingPlayersOutOfShip)
			{
				return false;
			}
			if ((Object)(object)localPlayer.hoveringOverTrigger != (Object)null && (localPlayer.hoveringOverTrigger.holdInteraction || !PlayerControllerBPatch.InteractTriggerUseConditionsMet_ReversePatch(localPlayer)))
			{
				return false;
			}
			return true;
		}

		private void LeadBot_performed(CallbackContext obj)
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			PlayerControllerB localPlayerController = StartOfRound.Instance.localPlayerController;
			if (!IsPerformedValid(localPlayerController))
			{
				return;
			}
			Ray val = default(Ray);
			((Ray)(ref val))..ctor(((Component)localPlayerController.gameplayCamera).transform.position, ((Component)localPlayerController.gameplayCamera).transform.forward);
			RaycastHit[] array = Physics.RaycastAll(val, localPlayerController.grabDistance, 8);
			RaycastHit[] array2 = array;
			for (int i = 0; i < array2.Length; i++)
			{
				RaycastHit val2 = array2[i];
				if (((Component)((RaycastHit)(ref val2)).collider).tag != "Player")
				{
					continue;
				}
				PlayerControllerB component = ((Component)((RaycastHit)(ref val2)).collider).gameObject.GetComponent<PlayerControllerB>();
				if ((Object)(object)component == (Object)null)
				{
					continue;
				}
				LethalBotAI lethalBotAI = LethalBotManager.Instance.GetLethalBotAI(component);
				if ((Object)(object)lethalBotAI == (Object)null || lethalBotAI.IsSpawningAnimationRunning())
				{
					continue;
				}
				EnumAIStates aIState = lethalBotAI.State.GetAIState();
				if (((NetworkBehaviour)lethalBotAI).OwnerClientId != localPlayerController.actualClientId || !lethalBotAI.IsFollowingLocalPlayer())
				{
					if (lethalBotAI.IsInSpecialAnimation())
					{
						HUDManager.Instance.DisplayTip("Bot is busy!", "If the bot is on the terminal, you can type 'hop off the terminal' to get them to hop off for a few seconds.", false, false, "LC_Tip1");
						break;
					}
					lethalBotAI.LethalBotIdentity.Voice.TryPlayVoiceAudio(new PlayVoiceParameters
					{
						VoiceState = EnumVoicesState.OrderedToFollow,
						CanTalkIfOtherLethalBotTalk = true,
						WaitForCooldown = false,
						CutCurrentVoiceStateToTalk = true,
						CanRepeatVoiceState = false,
						ShouldSync = true,
						IsLethalBotInside = component.isInsideFactory,
						AllowSwearing = Plugin.Config.AllowSwearing.Value
					});
					GroupManager.Instance.CreateOrJoinGroupWithMembersAndSync(localPlayerController, (PlayerControllerB[])(object)new PlayerControllerB[1] { component });
					lethalBotAI.SyncAssignTargetAndSetMovingTo(localPlayerController);
					if (Plugin.Config.ChangeSuitAutoBehaviour.Value)
					{
						lethalBotAI.ChangeSuitLethalBotServerRpc(component.playerClientId, localPlayerController.currentSuitID);
					}
				}
				else if (aIState != EnumAIStates.SearchingForScrap)
				{
					if (GroupManager.Instance.ArePlayersInSameGroup(component, localPlayerController))
					{
						GroupManager.Instance.RemoveFromCurrentGroupAndSync(component);
					}
					lethalBotAI.State = new SearchingForScrapState(lethalBotAI.State);
					((EnemyAI)lethalBotAI).targetPlayer = null;
				}
				break;
			}
		}

		private void GiveTakeItem_performed(CallbackContext obj)
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			PlayerControllerB localPlayerController = StartOfRound.Instance.localPlayerController;
			if (!IsPerformedValid(localPlayerController))
			{
				return;
			}
			Ray val = default(Ray);
			((Ray)(ref val))..ctor(((Component)localPlayerController.gameplayCamera).transform.position, ((Component)localPlayerController.gameplayCamera).transform.forward);
			RaycastHit[] array = Physics.RaycastAll(val, localPlayerController.grabDistance, 8);
			RaycastHit[] array2 = array;
			for (int i = 0; i < array2.Length; i++)
			{
				RaycastHit val2 = array2[i];
				if (((Component)((RaycastHit)(ref val2)).collider).tag != "Player")
				{
					continue;
				}
				PlayerControllerB component = ((Component)((RaycastHit)(ref val2)).collider).gameObject.GetComponent<PlayerControllerB>();
				if ((Object)(object)component == (Object)null)
				{
					continue;
				}
				LethalBotAI lethalBotAI = LethalBotManager.Instance.GetLethalBotAI(component);
				if ((Object)(object)lethalBotAI == (Object)null || lethalBotAI.IsSpawningAnimationRunning())
				{
					continue;
				}
				PatchesUtil.timeSinceSwitchingSlotsField.Invoke(localPlayerController) = 0f;
				if (!lethalBotAI.AreHandsFree())
				{
					lethalBotAI.DropItem();
				}
				else
				{
					if (!lethalBotAI.HasSomethingInInventory())
					{
						break;
					}
					GrabbableObject itemOnlySlot = component.ItemOnlySlot;
					if ((Object)(object)itemOnlySlot != (Object)null)
					{
						lethalBotAI.SwitchItemSlotsAndSync(50);
					}
					GrabbableObject[] itemSlots = lethalBotAI.NpcController.Npc.ItemSlots;
					for (int j = 0; j < itemSlots.Length; j++)
					{
						if ((Object)(object)itemSlots[j] != (Object)null)
						{
							lethalBotAI.SwitchItemSlotsAndSync(j);
						}
					}
				}
				break;
			}
		}

		private void ChangeSuitLethalBot_performed(CallbackContext obj)
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			PlayerControllerB localPlayerController = StartOfRound.Instance.localPlayerController;
			if (!IsPerformedValid(localPlayerController))
			{
				return;
			}
			Ray val = default(Ray);
			((Ray)(ref val))..ctor(((Component)localPlayerController.gameplayCamera).transform.position, ((Component)localPlayerController.gameplayCamera).transform.forward);
			RaycastHit[] array = Physics.RaycastAll(val, localPlayerController.grabDistance, 8);
			RaycastHit[] array2 = array;
			for (int i = 0; i < array2.Length; i++)
			{
				RaycastHit val2 = array2[i];
				if (((Component)((RaycastHit)(ref val2)).collider).tag != "Player")
				{
					continue;
				}
				PlayerControllerB component = ((Component)((RaycastHit)(ref val2)).collider).gameObject.GetComponent<PlayerControllerB>();
				if (!((Object)(object)component == (Object)null))
				{
					LethalBotAI lethalBotAI = LethalBotManager.Instance.GetLethalBotAI(component);
					if (!((Object)(object)lethalBotAI == (Object)null) && !lethalBotAI.IsSpawningAnimationRunning())
					{
						lethalBotAI.ChangeSuitLethalBotServerRpc(lethalBotAI.NpcController.Npc.playerClientId, localPlayerController.currentSuitID);
						break;
					}
				}
			}
		}
	}
	public class LethalBotManager : NetworkBehaviour
	{
		[CompilerGenerated]
		private sealed class <>c__DisplayClass114_0
		{
			public NetworkObject networkObject;

			public float startTime;

			internal bool <WaitBeforeSpawnOnClient>b__0()
			{
				if (!((Object)(object)networkObject != (Object)null) || !networkObject.IsSpawned)
				{
					return Time.realtimeSinceStartup - startTime > 5f;
				}
				return true;
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass123_0
		{
			public NetworkBehaviour playerPhoneNetworkBehavior;

			public float startTime;

			internal bool <togglePhoneModelAfterSpawn>b__0()
			{
				if (!((Object)(object)playerPhoneNetworkBehavior == (Object)null) && !playerPhoneNetworkBehavior.IsSpawned)
				{
					return Time.realtimeSinceStartup - startTime > 5f;
				}
				return true;
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass158_0
		{
			public float startTime;

			public LethalBotManager <>4__this;

			internal bool <SpawnLethalBotsCoroutine>b__0()
			{
				if (<>4__this.botSpawned.Value == EnumBotSpawnState.Unknown)
				{
					return Time.realtimeSinceStartup - startTime > 5f;
				}
				return true;
			}
		}

		[CompilerGenerated]
		private sealed class <BeamOutLethalBots>d__164 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public LethalBotManager <>4__this;

			public ShipTeleporter teleporter;

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

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

			[DebuggerHidden]
			public <BeamOutLethalBots>d__164(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_002a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0034: Expected O, but got Unknown
				//IL_005a: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
				//IL_0133: Unknown result type (might be due to invalid IL or missing references)
				//IL_0140: Unknown result type (might be due to invalid IL or missing references)
				//IL_0145: Unknown result type (might be due to invalid IL or missing references)
				//IL_014a: Unknown result type (might be due to invalid IL or missing references)
				//IL_012c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0131: Unknown result type (might be due to invalid IL or missing references)
				//IL_017c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0181: Unknown result type (might be due to invalid IL or missing references)
				//IL_01b5: Unknown result type (might be due to invalid IL or missing references)
				//IL_01c9: Unknown result type (might be due to invalid IL or missing references)
				//IL_019f: Unknown result type (might be due to invalid IL or missing references)
				int num = <>1__state;
				LethalBotManager lethalBotManager = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					IsInverseTeleporterActive = true;
					<>2__current = (object)new WaitForSeconds(5f);
					<>1__state = 1;
					return true;
				case 1:
				{
					<>1__state = -1;
					if (StartOfRound.Instance.inShipPhase)
					{
						IsInverseTeleporterActive = false;
						return false;
					}
					Vector3 val = default(Vector3);
					AudioReverbPresets val2 = Object.FindObjectOfType<AudioReverbPresets>();
					LethalBotAI[] lethalBotsAIOwnedByLocal = lethalBotManager.GetLethalBotsAIOwnedByLocal();
					LethalBotAI[] array = lethalBotsAIOwnedByLocal;
					foreach (LethalBotAI lethalBotAI in array)
					{
						if ((Object)(object)lethalBotAI == (Object)null || !((NetworkBehaviour)lethalBotAI).IsSpawned || ((EnemyAI)lethalBotAI).isEnemyDead || lethalBotAI.NpcController == null || lethalBotAI.NpcController.Npc.isPlayerDead || !lethalBotAI.NpcController.Npc.isPlayerControlled)
						{
							continue;
						}
						Vector3 position = ((Component)lethalBotAI.NpcController.Npc).transform.position;
						if ((Object)(object)lethalBotAI.NpcController.Npc.deadBody != (Object)null)
						{
							position = ((Component)lethalBotAI.NpcController.Npc.deadBody.bodyParts[5]).transform.position;
						}
						Vector3 val3 = position - teleporter.teleportOutPosition.position;
						if (!(((Vector3)(ref val3)).sqrMagnitude > 4f))
						{
							PlayerControllerB npc = lethalBotAI.NpcController.Npc;
							ShipTeleporterPatch.SetPlayerTeleporterId_ReversePatch(teleporter, npc, 2);
							val = ShipTeleporterPatch.GetInverseTelePosition_ReversePatch(teleporter);
							if ((Object)(object)npc.deadBody != (Object)null)
							{
								teleporter.TeleportPlayerBodyOutServerRpc((int)npc.playerClientId, val);
								continue;
							}
							ShipTeleporterPatch.TeleportPlayerOutWithInverseTeleporter_ReversePatch(teleporter, (int)npc.playerClientId, val);
							teleporter.TeleportPlayerOutServerRpc((int)npc.playerClientId, val);
						}
					}
					IsInverseTeleporterActive = false;
					return false;
				}
				}
			}

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

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

		[CompilerGenerated]
		private sealed class <MarkBotsAsGeneratedFloorWhenHumanPlayersReady>d__208 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public LethalBotManager <>4__this;

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

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

			[DebuggerHidden]
			public <MarkBotsAsGeneratedFloorWhenHumanPlayersReady>d__208(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_004d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0057: Expected O, but got Unknown
				int num = <>1__state;
				LethalBotManager CS$<>8__locals0 = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = null;
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<>2__current = (object)new WaitUntil((Func<bool>)(() => RoundManager.Instance.playersFinishedGeneratingFloor.Count >= CS$<>8__locals0.AllRealPlayersCount));
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					CS$<>8__locals0.MarkBotsAsGeneratedFloor();
					CS$<>8__locals0.markBotsAsGeneratedFloorCoroutine = null;
					return false;
				}
			}

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

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

		[CompilerGenerated]
		private sealed class <MarkBotsAsLoadedWhenHumanPlayersReady>d__205 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public LethalBotManager <>4__this;

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

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

			[DebuggerHidden]
			public <MarkBotsAsLoadedWhenHumanPlayersReady>d__205(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_004d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0057: Expected O, but got Unknown
				int num = <>1__state;
				LethalBotManager CS$<>8__locals0 = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = null;
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<>2__current = (object)new WaitUntil((Func<bool>)(() => StartOfRound.Instance.fullyLoadedPlayers.Count >= CS$<>8__locals0.AllRealPlayersCount));
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					CS$<>8__locals0.MarkBotsAsLoaded();
					CS$<>8__locals0.markBotsAsLoadedCoroutine = null;
					return false;
				}
			}

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

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

		[CompilerGenerated]
		private sealed class <ReenableNavMeshBlockerDelayed>d__213 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public LethalBotManager <>4__this;

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

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

			[DebuggerHidden]
			public <ReenableNavMeshBlockerDelayed>d__213(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0064: Unknown result type (might be due to invalid IL or missing references)
				//IL_006e: Expected O, but got Unknown
				int num = <>1__state;
				LethalBotManager lethalBotManager = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = null;
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<>2__current = (object)new WaitUntil((Func<bool>)(() => (Object)(object)StartOfRound.Instance == (Object)null || StartOfRound.Instance.shipDoorsEnabled));
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					<>2__current = null;
					<>1__state = 3;
					return true;
				case 3:
				{
					<>1__state = -1;
					NavMeshObstacle landingShipNavObstacle = lethalBotManager.landingShipNavObstacle;
					if (landingShipNavObstacle != null)
					{
						landingShipNavObstacle.height = lethalBotManager.landingShipNavObstacleInfo.height;
					}
					NavMeshObstacle landingShipNavObstacle2 = lethalBotManager.landingShipNavObstacle;
					if (landingShipNavObstacle2 != null)
					{
						landingShipNavObstacle2.radius = lethalBotManager.landingShipNavObstacleInfo.radius;
					}
					lethalBotManager.disableNavMeshCoroutine = null;
					return false;
				}
				}
			}

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

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

		[CompilerGenerated]
		private sealed class <RegisterItemsCoroutine>d__86 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public bool updateShipState;

			public LethalBotManager <>4__this;

			private HashSet<Light> <lightsOnMap>5__2;

			private List<GameObject> <grabbableObjectsInMap>5__3;

			private Light[] <lights>5__4;

			private HashSet<Light> <lightsToIgnore>5__5;

			private GrabbableObject[] <array>5__6;

			private int <i>5__7;

			private GrabbableObject <grabbableObject>5__8;

			private Light <light>5__9;

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

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

			[DebuggerHidden]
			public <RegisterItemsCoroutine>d__86(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<lightsOnMap>5__2 = null;
				<grabbableObjectsInMap>5__3 = null;
				<lights>5__4 = null;
				<lightsToIgnore>5__5 = null;
				<array>5__6 = null;
				<grabbableObject>5__8 = null;
				<light>5__9 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0115: Unknown result type (might be due to invalid IL or missing references)
				//IL_011b: Unknown result type (might be due to invalid IL or missing references)
				//IL_011d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0122: Unknown result type (might be due to invalid IL or missing references)
				//IL_012d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0132: Unknown result type (might be due to invalid IL or missing references)
				//IL_0136: Unknown result type (might be due to invalid IL or missing references)
				//IL_0162: Unknown result type (might be due to invalid IL or missing references)
				//IL_0167: Unknown result type (might be due to invalid IL or missing references)
				//IL_016b: Unknown result type (might be due to invalid IL or missing references)
				int num = <>1__state;
				LethalBotManager lethalBotManager = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<lightsOnMap>5__2 = new HashSet<Light>();
					<grabbableObjectsInMap>5__3 = new List<GameObject>();
					<>2__current = null;
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<lights>5__4 = Object.FindObjectsOfType<Light>();
					<lightsToIgnore>5__5 = new HashSet<Light>();
					<array>5__6 = Object.FindObjectsOfType<GrabbableObject>();
					Plugin.LogDebug($"Bot register grabbable objects, found: {<array>5__6.Length}");
					Plugin.LogDebug($"Bot register lights, found: {<lights>5__4.Length}");
					<i>5__7 = 0;
					goto IL_021f;
				case 2:
					<>1__state = -1;
					goto IL_00f4;
				case 3:
					{
						<>1__state = -1;
						goto IL_0270;
					}
					IL_021f:
					if (<i>5__7 < <array>5__6.Length)
					{
						<grabbableObject>5__8 = <array>5__6[<i>5__7];
						if (<i>5__7 % 20 == 0)
						{
							<>2__current = null;
							<>1__state = 2;
							return true;
						}
						goto IL_00f4;
					}
					<i>5__7 = 0;
					goto IL_02a0;
					IL_0270:
					TryRegisterLight(<light>5__9, <lightsOnMap>5__2, <lightsToIgnore>5__5);
					<light>5__9 = null;
					<i>5__7++;
					goto IL_02a0;
					IL_02a0:
					if (<i>5__7 < <lights>5__4.Length)
					{
						<light>5__9 = <lights>5__4[<i>5__7];
						if (<i>5__7 % 20 == 0)
						{
							<>2__current = null;
							<>1__state = 3;
							return true;
						}
						goto IL_0270;
					}
					lightsOnMap = <lightsOnMap>5__2;
					grabbableObjectsInMap = <grabbableObjectsInMap>5__3;
					lethalBotManager.timerUpdateLightsOnMap = 0f;
					lethalBotManager.registerItemsCoroutine = null;
					return false;
					IL_00f4:
					if ((Object)(object)<grabbableObject>5__8 != (Object)null)
					{
						if (updateShipState)
						{
							Vector3 itemFloorPosition = <grabbableObject>5__8.GetItemFloorPosition(default(Vector3));
							Bounds bounds = StartOfRound.Instance.shipStrictInnerRoomBounds.bounds;
							if (((Bounds)(ref bounds)).Contains(itemFloorPosition))
							{
								<grabbableObject>5__8.isInElevator = true;
								<grabbableObject>5__8.isInShipRoom = true;
							}
							else
							{
								bounds = StartOfRound.Instance.shipBounds.bounds;
								if (((Bounds)(ref bounds)).Contains(itemFloorPosition))
								{
									<grabbableObject>5__8.isInElevator = true;
								}
							}
						}
						if (!<grabbableObjectsInMap>5__3.Contains(((Component)<grabbableObject>5__8).gameObject))
						{
							<grabbableObjectsInMap>5__3.Add(((Component)<grabbableObject>5__8).gameObject);
						}
						GrabbableObject obj = <grabbableObject>5__8;
						FlashlightItem val = (FlashlightItem)(object)((obj is FlashlightItem) ? obj : null);
						if (val != null)
						{
							<lightsToIgnore>5__5.Add(val.flashlightBulb);
							<lightsToIgnore>5__5.Add(val.flashlightBulbGlow);
						}
						else
						{
							GrabbableObject obj2 = <grabbableObject>5__8;
							WalkieTalkie val2 = (WalkieTalkie)(object)((obj2 is WalkieTalkie) ? obj2 : null);
							if (val2 != null)
							{
								<lightsToIgnore>5__5.Add(val2.walkieTalkieLight);
							}
						}
					}
					<grabbableObject>5__8 = null;
					<i>5__7++;
					goto IL_021f;
				}
			}

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

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

		[CompilerGenerated]
		private sealed class <SpawnLethalBotsCoroutine>d__158 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public LethalBotManager <>4__this;

			public bool markBotsAsLoaded;

			private int <nbSpawnedBots>5__2;

			private StartOfRound <instanceSOR>5__3;

			private int <newPlayerCount>5__4;

			private int <newLivingPlayerCount>5__5;

			private int <i>5__6;

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

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

			[DebuggerHidden]
			public <SpawnLethalBotsCoroutine>d__158(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<instanceSOR>5__3 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
				//IL_02ab: Unknown result type (might be due to invalid IL or missing references)
				//IL_02b1: Unknown result type (might be due to invalid IL or missing references)
				//IL_01ab: Unknown result type (might be due to invalid IL or missing references)
				//IL_01b5: Expected O, but got Unknown
				int num = <>1__state;
				LethalBotManager lethalBotManager = <>4__this;
				int nextAvailablePlayerObject;
				PlayerControllerB val;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = null;
					<>1__state = 1;
					return true;
				case 1:
				{
					<>1__state = -1;
					<nbSpawnedBots>5__2 = 0;
					int num2 = SyncedEntry<int>.op_Implicit(Plugin.Config.MaxBotsAllowedToSpawn);
					<instanceSOR>5__3 = StartOfRound.Instance;
					<newPlayerCount>5__4 = <instanceSOR>5__3.connectedPlayersAmount;
					<newLivingPlayerCount>5__5 = <instanceSOR>5__3.livingPlayers;
					lethalBotManager.isSpawningBots.Value = true;
					Plugin.LogDebug("Preparing to spawn bots!");
					for (int i = 0; i < lethalBotManager.AllLethalBotAIs.Length; i++)
					{
						LethalBotAI lethalBotAI = lethalBotManager.AllLethalBotAIs[i];
						Plugin.LogDebug($"AI at index {i}: {lethalBotAI}");
						if ((Object)(object)lethalBotAI != (Object)null)
						{
							lethalBotManager.ReinitSpawnedBotServerRpc(NetworkObjectReference.op_Implicit(((NetworkBehaviour)lethalBotAI).NetworkObject));
							num2--;
						}
					}
					<i>5__6 = num2;
					goto IL_0246;
				}
				case 2:
					{
						<>1__state = -1;
						if (lethalBotManager.botSpawned.Value == EnumBotSpawnState.Unknown)
						{
							Plugin.LogWarning("Failed to get response from the host!");
						}
						else if (lethalBotManager.botSpawned.Value == EnumBotSpawnState.Spawned)
						{
							<newPlayerCount>5__4++;
							<newLivingPlayerCount>5__5++;
							<nbSpawnedBots>5__2++;
						}
						else if (lethalBotManager.botSpawned.Value == EnumBotSpawnState.NotSpawned)
						{
							Plugin.LogError("Failed to spawn bot on the host!");
						}
						goto IL_0234;
					}
					IL_0234:
					<i>5__6--;
					goto IL_0246;
					IL_0246:
					if (<i>5__6 <= 0)
					{
						break;
					}
					nextAvailablePlayerObject = lethalBotManager.GetNextAvailablePlayerObject();
					if (nextAvailablePlayerObject < 0)
					{
						Plugin.LogWarning("No available player objects to spawn any more lethal bots!");
						break;
					}
					val = <instanceSOR>5__3.allPlayerScripts[nextAvailablePlayerObject];
					if (!val.isPlayerControlled && !val.isPlayerDead)
					{
						<>c__DisplayClass158_0 CS$<>8__locals0 = new <>c__DisplayClass158_0
						{
							<>4__this = lethalBotManager
						};
						lethalBotManager.botSpawned.Value = EnumBotSpawnState.Unknown;
						lethalBotManager.SpawnLethalBotServerRpc(new SpawnLethalBotParamsNetworkSerializable
						{
							enumSpawnAnimation = EnumSpawnAnimation.OnlyPlayerSpawnAnimationIfDead,
							SpawnPosition = null,
							YRot = 0f,
							IsOutside = true
						});
						CS$<>8__locals0.startTime = Time.realtimeSinceStartup;
						<>2__current = (object)new WaitUntil((Func<bool>)(() => CS$<>8__locals0.<>4__this.botSpawned.Value != 0 || Time.realtimeSinceStartup - CS$<>8__locals0.startTime > 5f));
						<>1__state = 2;
						return true;
					}
					goto IL_0234;
				}
				Plugin.LogDebug("Finished spawning bots!");
				for (int j = 0; j < lethalBotManager.AllLethalBotAIs.Length; j++)
				{
					Plugin.LogDebug($"AI at index {j}: {lethalBotManager.AllLethalBotAIs[j]}");
				}
				lethalBotManager.SendNewPlayerCountServerRpc(<newPlayerCount>5__4, <newLivingPlayerCount>5__5, GameNetworkManager.Instance.connectedPlayers);
				lethalBotManager.isSpawningBots.Value = false;
				if (Plugin.IsModReviveCompanyLoaded)
				{
					lethalBotManager.SetStartingRevivesReviveCompanyServerRpc();
				}
				if (<nbSpawnedBots>5__2 > 0)
				{
					HUDManager.Instance.DisplayTip("Finished Spawning Bots!", $"{<nbSpawnedBots>5__2} bots were spawned!", false, false, "LC_Tip1");
				}
				if (markBotsAsLoaded)
				{
					lethalBotManager.MarkBotsAsLoadedDelayed();
				}
				lethalBotManager.spawnLethalBotsAtShipCoroutine = null;
				return false;
			}

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

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

		[CompilerGenerated]
		private sealed class <SyncLethalBotsToJoiningPlayer>d__227 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public SpawnLethalBotParamsNetworkSerializable[] spawnLethalBotParamsNetworkSerializable;

			public LethalBotManager <>4__this;

			private int <i>5__2;

			private SpawnLethalBotParamsNetworkSerializable <lethalBotData>5__3;

			private NetworkObject <networkObject>5__4;

			private float <startTime>5__5;

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

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

			[DebuggerHidden]
			public <SyncLethalBotsToJoiningPlayer>d__227(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<networkObject>5__4 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
				//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d9: Expected O, but got Unknown
				int num = <>1__state;
				LethalBotManager lethalBotManager = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = null;
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<i>5__2 = 0;
					goto IL_0196;
				case 2:
					{
						<>1__state = -1;
						goto IL_00e9;
					}
					IL_0196:
					if (<i>5__2 < spawnLethalBotParamsNetworkSerializable.Length)
					{
						<lethalBotData>5__3 = spawnLethalBotParamsNetworkSerializable[<i>5__2];
						if (!<lethalBotData>5__3.LethalBotReference.HasValue)
						{
							Plugin.LogInfo($"No bot data found for index {<i>5__2}!");
							goto IL_0184;
						}
						<networkObject>5__4 = null;
						<startTime>5__5 = Time.realtimeSinceStartup;
						goto IL_00e9;
					}
					return false;
					IL_00e9:
					if (Time.realtimeSinceStartup - <startTime>5__5 < 5f)
					{
						NetworkObjectReference value = <lethalBotData>5__3.LethalBotReference.Value;
						if (!((NetworkObjectReference)(ref value)).TryGet(ref <networkObject>5__4, (NetworkManager)null))
						{
							<>2__current = (object)new WaitForSeconds(0.2f);
							<>1__state = 2;
							return true;
						}
					}
					if ((Object)(object)<networkObject>5__4 == (Object)null)
					{
						Plugin.LogError($"Bot at index {<i>5__2} network object took too long to load!");
					}
					else
					{
						LethalBotAI component = ((Component)<networkObject>5__4).gameObject.GetComponent<LethalBotAI>();
						if ((Object)(object)component == (Object)null)
						{
							Plugin.LogError($"Bot at index {<i>5__2} network object didn't have LethalBotAI instance!");
						}
						else
						{
							lethalBotManager.AllLethalBotAIs[<lethalBotData>5__3.IndexNextLethalBot] = component;
							lethalBotManager.InitLethalBotSpawning(component, <lethalBotData>5__3, clientJoining: true);
							<networkObject>5__4 = null;
						}
					}
					goto IL_0184;
					IL_0184:
					<i>5__2++;
					goto IL_0196;
				}
			}

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

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

		[CompilerGenerated]
		private sealed class <WaitBeforeSpawnOnClient>d__114 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public NetworkObject networkObject;

			private <>c__DisplayClass114_0 <>8__1;

			public LethalBotManager <>4__this;

			public SpawnLethalBotParamsNetworkSerializable spawnLethalBotParamsNetworkSerializable;

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

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

			[DebuggerHidden]
			public <WaitBeforeSpawnOnClient>d__114(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>8__1 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_007e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0088: Expected O, but got Unknown
				//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
				int num = <>1__state;
				LethalBotManager lethalBotManager = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>8__1 = new <>c__DisplayClass114_0();
					<>8__1.networkObject = networkObject;
					<>2__current = null;
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<>8__1.startTime = Time.realtimeSinceStartup;
					<>2__current = (object)new WaitUntil((Func<bool>)(() => ((Object)(object)<>8__1.networkObject != (Object)null && <>8__1.networkObject.IsSpawned) || Time.realtimeSinceStartup - <>8__1.startTime > 5f));
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					lethalBotManager.SpawnLethalBotClientRpc(NetworkObjectReference.op_Implicit(<>8__1.networkObject), spawnLethalBotParamsNetworkSerializable);
					return false;
				}
			}

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

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

		[CompilerGenerated]
		private sealed class <togglePhoneModelAfterSpawn>d__123 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public NetworkBehaviour playerPhoneNetworkBehavior;

			private <>c__DisplayClass123_0 <>8__1;

			public string botName;

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

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

			[DebuggerHidden]
			public <togglePhoneModelAfterSpawn>d__123(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>8__1 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0077: Unknown result type (might be due to invalid IL or missing references)
				//IL_0081: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>8__1 = new <>c__DisplayClass123_0();
					<>8__1.playerPhoneNetworkBehavior = playerPhoneNetworkBehavior;
					<>8__1.startTime = Time.realtimeSinceStartup;
					<>2__current = null;
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<>2__current = (object)new WaitUntil((Func<bool>)(() => (Object)(object)<>8__1.playerPhoneNetworkBehavior == (Object)null || <>8__1.playerPhoneNetworkBehavior.IsSpawned || Time.realtimeSinceStartup - <>8__1.startTime > 5f));
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					if ((Object)(object)<>8__1.playerPhoneNetworkBehavior != (Object)null && <>8__1.playerPhoneNetworkBehavior.IsSpawned)
					{
						PhoneBehaviorPatch.TryWithPhone((Component)(object)<>8__1.playerPhoneNetworkBehavior, delegate(Component playerPhone)
						{
							//IL_0001: Unknown result type (might be due to invalid IL or missing references)
							((PlayerPhone)playerPhone).ToggleServerPhoneModelServerRpc(false);
						});
					}
					else
					{
						Plugin.LogWarning("Phone for bot " + botName + " failed to spawn after waiting, it may be desynced with the server!");
					}
					return false;
				}
			}

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

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

		[CompilerGenerated]
		private sealed class <trappedPlayerCheck>d__167 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public LethalBotManager <>4__this;

			private StartOfRound <instanceSOR>5__2;

			private bool <foundTrappedPlayer>5__3;

			private int <i>5__4;

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

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

			[DebuggerHidden]
			public <trappedPlayerCheck>d__167(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<instanceSOR>5__2 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f8: Expected O, but got Unknown
				int num = <>1__state;
				LethalBotManager lethalBotManager = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = null;
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<instanceSOR>5__2 = StartOfRound.Instance;
					goto IL_0108;
				case 2:
					<>1__state = -1;
					goto IL_00b8;
				case 3:
					{
						<>1__state = -1;
						goto IL_0108;
					}
					IL_0108:
					if (!((Object)(object)<instanceSOR>5__2 != (Object)null) || !IsTheShipLanded(<instanceSOR>5__2))
					{
						break;
					}
					<foundTrappedPlayer>5__3 = false;
					<i>5__4 = 0;
					goto IL_00c8;
					IL_00b8:
					<i>5__4++;
					goto IL_00c8;
					IL_00c8:
					if (<i>5__4 < <instanceSOR>5__2.allPlayerScripts.Length)
					{
						PlayerControllerB val = <instanceSOR>5__2.allPlayerScripts[<i>5__4];
						if (!val.isPlayerControlled || val.isPlayerDead || !val.isInsideFactory)
						{
							goto IL_00b8;
						}
						if (lethalBotManager.CanPlayerPathToExit(val))
						{
							<>2__current = null;
							<>1__state = 2;
							return true;
						}
						<foundTrappedPlayer>5__3 = true;
					}
					IsThereATrappedPlayer = <foundTrappedPlayer>5__3;
					<>2__current = (object)new WaitForSeconds(2.5f);
					<>1__state = 3;
					return true;
				}
				lethalBotManager.trappedPlayerCheckCoroutine = null;
				return false;
			}

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

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

		public int AllEntitiesCount;

		public NetworkVariable<EnumBotSpawnState> botSpawned = new NetworkVariable<EnumBotSpawnState>(EnumBotSpawnState.Unknown, (NetworkVariableReadPermission)0, (NetworkVariableWritePermission)0);

		public NetworkVariable<bool> sendPlayerCountUpdate = new NetworkVariable<bool>(false, (NetworkVariableReadPermission)0, (NetworkVariableWritePermission)0);

		public NetworkVariable<bool> isSpawningBots = new NetworkVariable<bool>(false, (NetworkVariableReadPermission)0, (NetworkVariableWritePermission)0);

		internal NetworkList<NetworkObjectReference> blacklistedNetworkList = new NetworkList<NetworkObjectReference>((IEnumerable<NetworkObjectReference>)null, (NetworkVariableReadPermission)0, (NetworkVariableWritePermission)0);

		public HashSet<GrabbableObject> blacklistedItems = new HashSet<GrabbableObject>();

		[CompilerGenerated]
		private static PlayerControllerB? <HostPlayerScript>k__BackingField;

		private NetworkVariable<NetworkBehaviourReference> _missionControlPlayer = new NetworkVariable<NetworkBehaviourReference>(default(NetworkBehaviourReference), (NetworkVariableReadPermission)0, (NetworkVariableWritePermission)0);

		public NetworkList<NetworkBehaviourReference> LootTransferPlayers = new NetworkList<NetworkBehaviourReference>((IEnumerable<NetworkBehaviourReference>)null, (NetworkVariableReadPermission)0, (NetworkVariableWritePermission)0);

		public static DayMode lastReportedTimeOfDay = (DayMode)0;

		[CompilerGenerated]
		private static DepositItemsDesk? <CompanyDesk>k__BackingField;

		[CompilerGenerated]
		private static HangarShipDoor? <ShipDoor>k__BackingField;

		public VehicleController? VehicleController;

		public NavMeshSurface shipNavMeshSurface;

		public GameObject? shipNavMeshInstance;

		public bool shipNavMeshActive;

		public NavMeshObstacle landingShipNavObstacle;

		public (float height, float radius) landingShipNavObstacleInfo = (0f, 0f);

		public Dictionary<EnemyAI, INoiseListener> DictEnemyAINoiseListeners = new Dictionary<EnemyAI, INoiseListener>();

		private LethalBotAI[] AllLethalBotAIs;

		private List<int> AllBotPlayerIndexs = new List<int>();

		private List<EndOfGameBotStats> AllBotEndOfGameStats = new List<EndOfGameBotStats>();

		private Coroutine registerItemsCoroutine;

		private Coroutine? spawnLethalBotsAtShipCoroutine;

		private Coroutine BeamOutLethalBotsCoroutine;

		private Coroutine? trappedPlayerCheckCoroutine;

		private Coroutine? disableNavMeshCoroutine;

		private Coroutine? markBotsAsLoadedCoroutine;

		private Coroutine? markBotsAsGeneratedFloorCoroutine;

		private ClientRpcParams ClientRpcParams;

		private static float nextCheckForShipSafety;

		private static bool _isShipCompromised;

		private float nextCheckForAliveHumanPlayers;

		private bool _areAllHumanPlayersDead;

		private float nextCheckForAllPlayersOnShip;

		private bool _areAllPlayersOnTheShip;

		private float timerRegisterAINoiseListener;

		private HashSet<EnemyAI> ListEnemyAINonNoiseListeners = new HashSet<EnemyAI>();

		private static Dictionary<Type, LethalBotThreat> DictionaryLethalBotThreats = new Dictionary<Type, LethalBotThreat>();

		public static List<GameObject> grabbableObjectsInMap = new List<GameObject>();

		private float timerUpdateLightsOnMap;

		private static HashSet<Light> lightsOnMap = new HashSet<Light>();

		public Dictionary<string, int> DictTagSurfaceIndex = new Dictionary<string, int>();

		private float timerSetLethalBotInElevator;

		private float timerUpdateOwnershipOfBot;

		private static bool registeredVoiceCommands = false;

		public static LethalBotManager Instance { get; private set; } = null;


		public int AllRealPlayersCount { get; private set; }

		public int IndexBeginOfInterns
		{
			get
			{
				if (!Plugin.IsModLethalInternsLoaded)
				{
					return int.MaxValue;
				}
				InternManager instance = InternManager.Instance;
				if (instance == null)
				{
					return int.MaxValue;
				}
				return instance.IndexBeginOfInterns;
			}
		}

		public static PlayerControllerB? HostPlayerScript
		{
			get
			{
				if ((Object)(object)<HostPlayerScript>k__BackingField == (Object)null || !<HostPlayerScript>k__BackingField.isHostPlayerObject)
				{
					PlayerControllerB[] allPlayerScripts = StartOfRound.Instance.allPlayerScripts;
					foreach (PlayerControllerB val in allPlayerScripts)
					{
						if ((Object)(object)val != (Object)null && val.isHostPlayerObject)
						{
							<HostPlayerScript>k__BackingField = val;
							break;
						}
					}
				}
				return <HostPlayerScript>k__BackingField;
			}
		}

		public PlayerControllerB? MissionControlPlayer
		{
			get
			{
				//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)
				NetworkBehaviourReference value = _missionControlPlayer.Value;
				PlayerControllerB result = default(PlayerControllerB);
				if (((NetworkBehaviourReference)(ref value)).TryGet<PlayerControllerB>(ref result, (NetworkManager)null))
				{
					return result;
				}
				return null;
			}
			set
			{
				//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_000b: Unknown result type (might be due to invalid IL or missing references)
				if ((Object)(object)value != (Object)null)
				{
					SetMissionControllerAndSync(NetworkBehaviourReference.op_Implicit((NetworkBehaviour)(object)value));
				}
				else
				{
					SetMissionControllerAndSync(default(NetworkBehaviourReference));
				}
			}
		}

		public static DepositItemsDesk? CompanyDesk
		{
			get
			{
				if ((Object)(object)<CompanyDesk>k__BackingField == (Object)null)
				{
					<CompanyDesk>k__BackingField = Object.FindObjectOfType<DepositItemsDesk>();
				}
				return <CompanyDesk>k__BackingField;
			}
		}

		public static HangarShipDoor? ShipDoor
		{
			get
			{
				if ((Object)(object)<ShipDoor>k__BackingField == (Object)null)
				{
					<ShipDoor>k__BackingField = Object.FindObjectOfType<HangarShipDoor>();
				}
				return <ShipDoor>k__BackingField;
			}
		}

		public bool shipNavMeshBuilt
		{
			get
			{
				if ((Object)(object)shipNavMeshSurface != (Object)null && (Object)(object)shipNavMeshSurface.navMeshData != (Object)null)
				{
					return (Object)(object)shipNavMeshInstance != (Object)null;
				}
				return false;
			}
		}

		public static bool IsInverseTeleporterActive { get; private set; }

		public static bool IsThereATrappedPlayer { get; private set; }

		public static IReadOnlyCollection<Light> LightsOnMap => lightsOnMap;

		private void Awake()
		{
			if ((Object)(object)Instance != (Object)null && (Object)(object)Instance != (Object)(object)this)
			{
				if (((NetworkBehaviour)Instance).IsSpawned && ((NetworkBehaviour)Instance).IsServer)
				{
					((NetworkBehaviour)Instance).NetworkObject.Despawn(true);
				}
				else
				{
					Object.Destroy((Object)(object)((Component)Instance).gameObject);
				}
			}
			Instance = this;
			((SyncedConfig2<Config>)(object)Plugin.Config).InitialSyncCompleted += Config_InitialSyncCompleted;
			Plugin.LogDebug($"Client {((NetworkBehaviour)this).NetworkManager.LocalClientId}, MaxBotsAllowedToSpawn before CSync {Plugin.Config.MaxBotsAllowedToSpawn.Value}");
			Plugin.LogDebug($"Saved instance: {Instance}, This object: {this}");
		}

		public override void OnNetworkSpawn()
		{
			((NetworkBehaviour)this).OnNetworkSpawn();
			blacklistedNetworkList.OnListChanged += OnBlacklistChanged;
			if (!((NetworkBehaviour)this).NetworkManager.IsServer)
			{
				if ((Object)(object)Instance != (Object)null && (Object)(object)Instance != (Object)(object)this)
				{
					Object.Destroy((Object)(object)((Component)Instance).gameObject);
				}
				Instance = this;
			}
		}

		public override void OnNetworkDespawn()
		{
			((NetworkBehaviour)this).OnNetworkDespawn();
			blacklistedNetworkList.OnListChanged -= OnBlacklistChanged;
		}

		public override void OnDestroy()
		{
			((NetworkBehaviour)this).OnDestroy();
			if ((Object)(object)shipNavMeshInstance != (Object)null)
			{
				Object.Destroy((Object)(object)shipNavMeshInstance);
			}
		}

		private void Config_InitialSyncCompleted(object sender, EventArgs e)
		{
			if (!((NetworkBehaviour)this).IsHost)
			{
				Plugin.LogDebug($"Client {((NetworkBehaviour)this).NetworkManager.LocalClientId}, ManagePoolOfBots after CSync, MaxBotsAllowedToSpawn {Plugin.Config.MaxBotsAllowedToSpawn.Value}");
				ManagePoolOfBots();
			}
		}

		private void FixedUpdate()
		{
			RegisterAINoiseListener(Time.fixedDeltaTime);
			timerUpdateLightsOnMap += Time.fixedDeltaTime;
			if (timerUpdateLightsOnMap >= 5f && registerItemsCoroutine == null)
			{
				timerUpdateLightsOnMap = 0f;
				RegisterItems(updateShipState: false);
			}
		}

		private void RegisterAINoiseListener(float deltaTime)
		{
			timerRegisterAINoiseListener += deltaTime;
			if (timerRegisterAINoiseListener < 1f)
			{
				return;
			}
			timerRegisterAINoiseListener = 0f;
			RoundManager instance = RoundManager.Instance;
			INoiseListener value = default(INoiseListener);
			foreach (EnemyAI spawnedEnemy in instance.SpawnedEnemies)
			{
				if (!ListEnemyAINonNoiseListeners.Contains(spawnedEnemy) && !DictEnemyAINoiseListeners.ContainsKey(spawnedEnemy))
				{
					if (((Component)spawnedEnemy).gameObject.TryGetComponent<INoiseListener>(ref value))
					{
						Plugin.LogDebug($"new enemy noise listener, spawnedEnemy {spawnedEnemy}");
						DictEnemyAINoiseListeners.Add(spawnedEnemy, value);
					}
					else
					{
						Plugin.LogDebug($"new enemy not noise listener, spawnedEnemy {spawnedEnemy}");
						ListEnemyAINonNoiseListeners.Add(spawnedEnemy);
					}
				}
			}
		}

		public void GrabbableObjectSpawned(GrabbableObject newItem)
		{
			if (!grabbableObjectsInMap.Contains(((Component)newItem).gameObject))
			{
				if (newItem is RagdollGrabbableObject)
				{
					LethalBotAI.DictJustDroppedItems[newItem] = Time.realtimeSinceStartup;
				}
				grabbableObjectsInMap.Add(((Component)newItem).gameObject);
			}
		}

		public void RegisterItems(bool updateShipState = true)
		{
			if (registerItemsCoroutine == null)
			{
				registerItemsCoroutine = ((MonoBehaviour)this).StartCoroutine(RegisterItemsCoroutine(updateShipState));
			}
		}

		[IteratorStateMachine(typeof(<RegisterItemsCoroutine>d__86))]
		private IEnumerator RegisterItemsCoroutine(bool updateShipState = true)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <RegisterItemsCoroutine>d__86(0)
			{
				<>4__this = this,
				updateShipState = updateShipState
			};
		}

		public static void TryRegisterLight(Light light, HashSet<Light>? targetSet = null, HashSet<Light>? ignoreList = null)
		{
			if (targetSet == null)
			{
				targetSet = lightsOnMap;
			}
			if (!((Object)(object)light == (Object)null) && (ignoreList == null || !ignoreList.Contains(light)) && !IsPlayerLight(light))
			{
				targetSet.Add(light);
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static void TryRemoveRegisteredLight(Light light)
		{
			lightsOnMap.Remove(light);
		}

		private static bool IsPlayerLight(Light light)
		{
			PlayerControllerB[] allPlayerScripts = StartOfRound.Instance.allPlayerScripts;
			foreach (PlayerControllerB val in allPlayerScripts)
			{
				if ((Object)(object)val.nightVision == (Object)(object)light || (Object)(object)val.nightVisionRadar == (Object)(object)light || (Object)(object)val.helmetLight == (Object)(object)light || val.allHelmetLights.Contains(light))
				{
					return true;
				}
			}
			return false;
		}

		[ClientRpc]
		private void DisplayTipClientRpc(string headerText, string bodyText, ClientRpcParams clientRpcParams = default(ClientRpcParams))
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: 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_013d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(233959231u, clientRpcParams, (RpcDelivery)0);
				bool flag = headerText != null;
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				if (flag)
				{
					((FastBufferWriter)(ref val)).WriteValueSafe(headerText, false);
				}
				bool flag2 = bodyText != null;
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref flag2, default(ForPrimitives));
				if (flag2)
				{
					((FastBufferWriter)(ref val)).WriteValueSafe(bodyText, false);
				}
				((NetworkBehaviour)this).__endSendClientRpc(ref val, 233959231u, clientRpcParams, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				HUDManager.Instance.DisplayTip(headerText, bodyText, false, false, "LC_Tip1");
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void RegisterItemAsBlacklistedServerRpc(NetworkObjectReference itemToBlacklist, ServerRpcParams rpcParams = default(ServerRpcParams))
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_0146: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(3128040487u, rpcParams, (RpcDelivery)0);
				((FastBufferWriter)(ref val)).WriteValueSafe<NetworkObjectReference>(ref itemToBlacklist, default(ForNetworkSerializable));
				((NetworkBehaviour)this).__endSendServerRpc(ref val, 3128040487u, rpcParams, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				ClientRpcParams.Send = new ClientRpcSendParams
				{
					TargetClientIds = new ulong[1] { rpcParams.Receive.SenderClientId }
				};
				if (RegisterItemAsBlacklisted(itemToBlacklist))
				{
					string headerText = "Success!";
					string bodyText = "Held Item successfully added to sell blacklist.";
					DisplayTipClientRpc(headerText, bodyText, ClientRpcParams);
				}
				else
				{
					string headerText2 = "Error!";
					string bodyText2 = "Failed to add Held Item to sell blacklist.";
					DisplayTipClientRpc(headerText2, bodyText2, ClientRpcParams);
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void RegisterItemsAsBlacklistedServerRpc(NetworkObjectReference[] itemsToBlacklist, ServerRpcParams rpcParams = default(ServerRpcParams))
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: 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_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Unknown result type (might be due to invalid IL or missing references)
			//IL_012a: Unknown result type (might be due to invalid IL or missing references)
			//IL_013a: Unknown result type (might be due to invalid IL or missing references)
			//IL_013b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_014a: Unknown result type (might be due to invalid IL or missing references)
			//IL_014f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0152: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_018e: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(1562394522u, rpcParams, (RpcDelivery)0);
				bool flag = itemsToBlacklist != null;
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				if (flag)
				{
					((FastBufferWriter)(ref val)).WriteValueSafe<NetworkObjectReference>(itemsToBlacklist, default(ForNetworkSerializable));
				}
				((NetworkBehaviour)this).__endSendServerRpc(ref val, 1562394522u, rpcParams, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage != 1 || (!networkManager.IsServer && !networkManager.IsHost))
			{
				return;
			}
			base.__rpc_exec_stage = (__RpcExecStage)0;
			ClientRpcParams.Send = new ClientRpcSendParams
			{
				TargetClientIds = new ulong[1] { rpcParams.Receive.SenderClientId }
			};
			int num = 0;
			foreach (NetworkObjectReference itemToBlacklist in itemsToBlacklist)
			{
				if (RegisterItemAsBlacklisted(itemToBlacklist))
				{
					num++;
				}
			}
			if (num >= itemsToBlacklist.Length)
			{
				string headerText = "Success!";
				string bodyText = $"{num} Item(s) successfully added to sell blacklist.";
				DisplayTipClientRpc(headerText, bodyText, ClientRpcParams);
			}
			else
			{
				string headerText2 = "Error!";
				string bodyText2 = $"Failed to add {itemsToBlacklist.Length - num} Item(s) to sell blacklist.";
				DisplayTipClientRpc(headerText2, bodyText2, ClientRpcParams);
			}
		}

		public bool RegisterItemAsBlacklisted(NetworkObjectReference itemToBlacklist)
		{
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			if (!((NetworkBehaviour)this).IsServer)
			{
				Plugin.LogWarning("LethalBotManager.RegisterItemAsBlacklisted was called on a non-host or non-server client. Aborting!");
				return false;
			}
			NetworkObject val = default(NetworkObject);
			if (!((NetworkObjectReference)(ref itemToBlacklist)).TryGet(ref val, (NetworkManager)null))
			{
				Plugin.LogWarning("LethalBotManager.RegisterItemAsBlacklisted: Failed to resolve NetworkObjectReference (likely despawned).");
				return false;
			}
			GrabbableObject component = ((Component)val).gameObject.GetComponent<GrabbableObject>();
			if ((Object)(object)component == (Object)null)
			{
				Plugin.LogError("LethalBotManager.RegisterItemAsBlacklisted: Failed to resolve GrabbableObject component from network object");
				return false;
			}
			if (!blacklistedNetworkList.Contains(itemToBlacklist))
			{
				blacklistedNetworkList.Add(itemToBlacklist);
			}
			return true;
		}

		[ServerRpc(RequireOwnership = false)]
		public void RemoveItemFromBlacklistServerRpc(NetworkObjectReference itemToBlacklist, ServerRpcParams rpcParams = default(ServerRpcParams))
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_0146: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(2605433549u, rpcParams, (RpcDelivery)0);
				((FastBufferWriter)(ref val)).WriteValueSafe<NetworkObjectReference>(ref itemToBlacklist, default(ForNetworkSerializable));
				((NetworkBehaviour)this).__endSendServerRpc(ref val, 2605433549u, rpcParams, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				ClientRpcParams.Send = new ClientRpcSendParams
				{
					TargetClientIds = new ulong[1] { rpcParams.Receive.SenderClientId }
				};
				if (RemoveItemFromBlacklist(itemToBlacklist))
				{
					string headerText = "Success!";
					string bodyText = "Held Item successfully removed sell blacklist.";
					DisplayTipClientRpc(headerText, bodyText, ClientRpcParams);
				}
				else
				{
					string headerText2 = "Error!";
					string bodyText2 = "Failed to remove Held Item from sell blacklist.";
					DisplayTipClientRpc(headerText2, bodyText2, ClientRpcParams);
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void RemoveItemsFromBlacklistServerRpc(NetworkObjectReference[] itemsToBlacklist, ServerRpcParams rpcParams = default(ServerRpcParams))
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: 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_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Unknown result type (might be due to invalid IL or missing references)
			//IL_012a: Unknown result type (might be due to invalid IL or missing references)
			//IL_013a: Unknown result type (might be due to invalid IL or missing references)
			//IL_013b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_014a: Unknown result type (might be due to invalid IL or missing references)
			//IL_014f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0152: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_018e: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(4229823977u, rpcParams, (RpcDelivery)0);
				bool flag = itemsToBlacklist != null;
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				if (flag)
				{
					((FastBufferWriter)(ref val)).WriteValueSafe<NetworkObjectReference>(itemsToBlacklist, default(ForNetworkSerializable));
				}
				((NetworkBehaviour)this).__endSendServerRpc(ref val, 4229823977u, rpcParams, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage != 1 || (!networkManager.IsServer && !networkManager.IsHost))
			{
				return;
			}
			base.__rpc_exec_stage = (__RpcExecStage)0;
			ClientRpcParams.Send = new ClientRpcSendParams
			{
				TargetClientIds = new ulong[1] { rpcParams.Receive.SenderClientId }
			};
			int num = 0;
			foreach (NetworkObjectReference itemToBlacklist in itemsToBlacklist)
			{
				if (RemoveItemFromBlacklist(itemToBlacklist))
				{
					num++;
				}
			}
			if (num >= itemsToBlacklist.Length)
			{
				string headerText = "Success!";
				string bodyText = $"{num} Item(s) successfully removed from sell blacklist.";
				DisplayTipClientRpc(headerText, bodyText, ClientRpcParams);
			}
			else
			{
				string headerText2 = "Error!";
				string bodyText2 = $"Failed to remove {itemsToBlacklist.Length - num} Item(s) from sell blacklist.";
				DisplayTipClientRpc(headerText2, bodyText2, ClientRpcParams);
			}
		}

		public bool RemoveItemFromBlacklist(NetworkObjectReference itemToBlacklist)
		{
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			if (!((NetworkBehaviour)this).IsServer)
			{
				Plugin.LogWarning("LethalBotManager.RemoveItemFromBlacklist was called on a non-host or non-server client. Aborting!");
				return false;
			}
			NetworkObject val = default(NetworkObject);
			if (!((NetworkObjectReference)(ref itemToBlacklist)).TryGet(ref val, (NetworkManager)null))
			{
				Plugin.LogWarning("LethalBotManager.RemoveItemFromBlacklist: Failed to resolve NetworkObjectReference (likely despawned).");
				return false;
			}
			GrabbableObject component = ((Component)val).gameObject.GetComponent<GrabbableObject>();
			if ((Object)(object)component == (Object)null)
			{
				Plugin.LogError("LethalBotManager.RemoveItemFromBlacklist: Failed to resolve GrabbableObject component from network object");
				return false;
			}
			blacklistedNetworkList.Remove(itemToBlacklist);
			return true;
		}

		private void OnBlacklistChanged(NetworkListEvent<NetworkObjectReference> change)
		{
			//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_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Expected I4, but got Unknown
			EventType<NetworkObjectReference> type = change.Type;
			switch ((int)type)
			{
			case 0:
			case 1:
			{
				NetworkObject val2 = default(NetworkObject);
				if (!((NetworkObjectReference)(ref change.Value)).TryGet(ref val2, (NetworkManager)null))
				{
					Plugin.LogWarning("LethalBotManager.OnBlacklistChanged: Failed to resolve NetworkObjectReference (likely despawned).");
					break;
				}
				GrabbableObject component2 = ((Component)val2).gameObject.GetComponent<GrabbableObject>();
				if ((Object)(object)component2 == (Object)null)
				{
					Plugin.LogError("LethalBotManager.OnBlacklistChanged: Failed to resolve GrabbableObject component from network object");
				}
				else
				{
					blacklistedItems.Add(component2);
				}
				break;
			}
			case 2:
			case 3:
			{
				NetworkObject val = default(NetworkObject);
				if (!((NetworkObjectReference)(ref change.Value)).TryGet(ref val, (NetworkManager)null))
				{
					Plugin.LogWarning("LethalBotManager.OnBlacklistChanged: Failed to resolve NetworkObjectReference (likely despawned).");
					break;
				}
				GrabbableObject component = ((Component)val).gameObject.GetComponent<GrabbableObject>();
				if ((Object)(object)component == (Object)null)
				{
					Plugin.LogError("LethalBotManager.OnBlacklistChanged: Failed to resolve GrabbableObject component from network object");
				}
				else
				{
					blacklistedItems.Remove(component);
				}
				break;
			}
			case 5:
				blacklistedItems.Clear();
				break;
			case 4:
				break;
			}
		}

		private void Start()
		{
			LoadoutManager.Instance.InitLoadouts(Plugin.Config.ConfigLoadouts.configLoadouts);
			IdentityManager.Instance.InitIdentities(Plugin.Config.ConfigIdentities.configIdentities);
			RestockManager.Instance.InitStockRequirements(Plugin.Config.ConfigStockRequirements.configStockRequirements);
			string text = Utility.CombinePaths(new string[2]
			{
				Paths.ConfigPath,
				"LethalBots"
			});
			Directory.CreateDirectory(text);
			Plugin.LogInfo("Listing all items in the game!");
			using (StreamWriter streamWriter = new StreamWriter(Utility.CombinePaths(new string[2] { text, "GameItems.txt" })))
			{
				streamWriter.WriteLine("Listing all items in the game!");
				foreach (Item items in StartOfRound.Instance.allItemsList.itemsList)
				{
					string text2 = $"Name: {items.itemName} with ID: {items.itemId}";
					streamWriter.WriteLine(text2);
					Plugin.LogInfo(text2);
				}
				Plugin.LogInfo("Listing all unlockable items in the game!");
				streamWriter.WriteLine("Listing all unlockable items in the game!");
				List<UnlockableItem> unlockables = StartOfRound.Instance.unlockablesList.unlockables;
				for (int i = 0; i < unlockables.Count; i++)
				{
					UnlockableItem val = unlockables[i];
					if (val != null)
					{
						string text3 = $"Name: {val.unlockableName} with ID: {i}";
						streamWriter.WriteLine(text3);
						Plugin.LogInfo(text3);
					}
				}
			}
			if (Plugin.PluginIrlPlayersCount > 0)
			{
				ManagePoolOfBots();
			}
			SaveManager.Instance.LoadAllDataFromSave();
			DictTagSurfaceIndex.Clear();
			for (int j = 0; j < StartOfRound.Instance.footstepSurfaces.Length; j++)
			{
				DictTagSurfaceIndex.Add(StartOfRound.Instance.footstepSurfaces[j].surfaceTag, j);
			}
			DictionaryLethalBotThreats.Clear();
			RegisterDefaultThreats();
			RegisterCustomThreats();
			RegisterDefaultCommands();
			RegisterCustomCommands();
			RegisterVoiceCommands();
		}

		private void Update()
		{
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			StartOfRound instance = StartOfRound.Instance;
			if (!isSpawningBots.Value && sendPlayerCountUpdate.Value && (((NetworkBehaviour)this).IsServer || ((NetworkBehaviour)this).IsHost))
			{
				int num = 0;
				PlayerControllerB[] allPlayerScripts = instance.allPlayerScripts;
				foreach (PlayerControllerB val in allPlayerScripts)
				{
					if (val.isPlayerControlled && !val.isPlayerDead)
					{
						num++;
					}
				}
				SendNewPlayerCountServerRpc(instance.connectedPlayersAmount, num, GameNetworkManager.Instance.connectedPlayers);
			}
			if (IsTheShipLanded(instance))
			{
				StartTrappedPlayerCoroutine();
			}
			else
			{
				StopTrappedPlayerCoroutine();
			}
		}

		public void ManagePoolOfBots()
		{
			StartOfRound instance = StartOfRound.Instance;
			if ((Object)(object)instance.allPlayerObjects[3].gameObject == (Object)null)
			{
				Plugin.LogInfo("No player objects initialized in game, aborting bots initializations.");
				return;
			}
			if (Plugin.PluginIrlPlayersCount == 0)
			{
				Plugin.PluginIrlPlayersCount = instance.allPlayerObjects.Length;
				Plugin.LogDebug($"PluginIrlPlayersCount = {Plugin.PluginIrlPlayersCount}");
			}
			int pluginIrlPlayersCount = Plugin.PluginIrlPlayersCount;
			if (AllLethalBotAIs == null)
			{
				AllLethalBotAIs = new LethalBotAI[pluginIrlPlayersCount];
			}
			else if (AllLethalBotAIs.Length != pluginIrlPlayersCount)
			{
				Array.Resize(ref AllLethalBotAIs, pluginIrlPlayersCount);
			}
			AllEntitiesCount = pluginIrlPlayersCount;
			if (instance.allPlayerScripts.Length == AllEntitiesCount)
			{
				Plugin.LogInfo($"Pool of bots ok. The arrays have not been resized, PluginIrlPlayersCount: {Plugin.PluginIrlPlayersCount}, arrays length: {instance.allPlayerScripts.Length}");
			}
			else
			{
				Plugin.LogInfo($"Pool of bots not ok. The arrays have been resized, PluginIrlPlayersCount: {Plugin.PluginIrlPlayersCount}, arrays length: {instance.allPlayerScripts.Length}");
			}
		}

		public void ResetIdentities()
		{
			if (((NetworkBehaviour)this).IsServer || ((NetworkBehaviour)this).IsHost)
			{
				IdentityManager.Instance.InitIdentities(Plugin.Config.ConfigIdentities.configIdentities);
				SyncLoadedJsonIdentitiesToAllClientsServerRpc();
			}
		}

		private void RemovePlayerModelReplacement(PlayerControllerB lethalBotController)
		{
			BodyReplacementBase component = ((Component)lethalBotController).GetComponent<BodyReplacementBase>();
			if (!((Object)(object)component == (Object)null))
			{
				RemovePlayerModelReplacement((object)component);
			}
		}

		private void RemovePlayerModelReplacement(object bodyReplacementBase)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Expected O, but got Unknown
			Object.DestroyImmediate((Object)(BodyReplacementBase)bodyReplacementBase);
		}

		private void RemoveCosmetics(PlayerControllerB lethalBotController)
		{
			CosmeticApplication componentInChildren = ((Component)lethalBotController).gameObject.GetComponentInChildren<CosmeticApplication>();
			if ((Object)(object)componentInChildren != (Object)null)
			{
				Plugin.LogDebug("clear cosmetics");
				componentInChildren.RefreshAllCosmeticPositions();
				componentInChildren.ClearCosmetics();
			}
		}

		public static float? GetFearRangeForEnemy(LethalBotFearQuery fearQuery)
		{
			if ((Object)(object)fearQuery.EnemyAI == (Object)null)
			{
				Plugin.LogWarning("GetFearRangeForEnemy: EnemyAI is null");
				return null;
			}
			Type type = ((object)fearQuery.EnemyAI).GetType();
			if (DictionaryLethalBotThreats.TryGetValue(type, out LethalBotThreat value))
			{
				return value.GetFearRangeForEnemy(fearQuery);
			}
			return null;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static void RegisterThreat(Type threatType, float? panik, float? mission, float? path)
		{
			RegisterThreat(threatType, (LethalBotFearQuery _) => panik, (LethalBotFearQuery _) => mission, (LethalBotFearQuery _) => path);
		}

		public static void RegisterThreat(Type threatType, Func<LethalBotFearQuery, float?> panik, Func<LethalBotFearQuery, float?> mission, Func<LethalBotFearQuery, float?> path)
		{
			if (DictionaryLethalBotThreats.ContainsKey(threatType))
			{
				Plugin.LogWarning("Threat '" + threatType.Name + "' was already registered. Overwriting!");
			}
			DictionaryLethalBotThreats[threatType] = new LethalBotThreat(threatType, panik, mission, path);
			Plugin.LogInfo("Registered " + threatType.Name + " as a threat to LethalBots!");
		}

		public static void UnRegisterThreat(Type theatType)
		{
			if (DictionaryLethalBotThreats.ContainsKey(theatType))
			{
				DictionaryLethalBotThreats.Remove(theatType);
			}
		}

		private static void RegisterDefaultThreats()
		{
			RegisterThreat(typeof(CrawlerAI), 20f, 10f, 20f);
			RegisterThreat(typeof(ForestGiantAI), 30f, 10f, 40f);
			RegisterThreat(typeof(SandWormAI), 10f, null, 15f);
			RegisterThreat(typeof(ClaySurgeonAI), 15f, null, 10f);
			RegisterThreat(typeof(FlowermanAI), 10f, null, 5f);
			RegisterThreat(typeof(BushWolfEnemy), 15f, 10f, 15f);
			RegisterThreat(typeof(PufferAI), 2f, null, 2f);
			RegisterThreat(typeof(RedLocustBees), 10f, null, 15f);
			RegisterThreat(typeof(ButlerBeesEnemyAI), 20f, null, 15f);
			RegisterThreat(typeof(BlobAI), 10f, null, 10f);
			RegisterThreat(typeof(BaboonBirdAI), 10f, 5f, 10f);
			RegisterThreat(typeof(PumaAI), 10f, null, 10f);
			RegisterThreat(typeof(CadaverBloomAI), 20f, null, 20f);
			RegisterThreat(typeof(RadMechAI), (LethalBotFearQuery fq) => (fq.EnemyAI.currentBehaviourStateIndex <= 0) ? null : new float?(30f), (LethalBotFearQuery fq) => (fq.EnemyAI.currentBehaviourStateIndex <= 0) ? null : new float?(20f), (LethalBotFearQuery fq) => 40f);
			RegisterThreat(typeof(CaveDwellerAI), (LethalBotFearQuery fq) => (fq.EnemyAI.currentBehaviourStateIndex <= 0) ? null : new float?(30f), (LethalBotFearQuery fq) => (fq.EnemyAI.currentBehaviourStateIndex <= 2) ? null : new float?(30f), (LethalBotFearQuery fq) => (fq.EnemyAI.currentBehaviourStateIndex <= 0) ? null : new float?(30f));
			RegisterThreat(typeof(JesterAI), (LethalBotFearQuery fq) => (fq.EnemyAI.currentBehaviourStateIndex <= 0) ? null : new float?(float.MaxValue), (LethalBotFearQuery fq) => (fq.EnemyAI.currentBehaviourStateIndex != 2 || (!((Object)(object)fq.PlayerToCheck == (Object)null) && !fq.PlayerToCheck.isInsideFactory)) ? null : new float?(float.MaxValue), (LethalBotFearQuery fq) => (fq.EnemyAI.currentBehaviourStateIndex <= 0) ? new float?(20f) : null);
			RegisterThreat(typeof(MouthDogAI), delegate(LethalBotFearQuery fq)
			{
				EnemyAI enemyAI12 = fq.EnemyAI;
				MouthDogAI val12 = (MouthDogAI)(object)((enemyAI12 is MouthDogAI) ? enemyAI12 : null);
				return (val12 != null && val12.suspicionLevel >= 9) ? 20f : 5f;
			}, delegate(LethalBotFearQuery fq)
			{
				EnemyAI enemyAI11 = fq.EnemyAI;
				MouthDogAI val11 = (MouthDogAI)(object)((enemyAI11 is MouthDogAI) ? enemyAI11 : null);
				return (val11 == null || val11.suspicionLevel < 9) ? null : new float?(20f);
			}, delegate(LethalBotFearQuery fq)
			{
				EnemyAI enemyAI10 = fq.EnemyAI;
				MouthDogAI val10 = (MouthDogAI)(object)((enemyAI10 is MouthDogAI) ? enemyAI10 : null);
				return (val10 != null && val10.suspicionLevel > 0) ? 30f : 20f;
			});
			RegisterThreat(typeof(CentipedeAI), delegate(LethalBotFearQuery fq)
			{
				EnemyAI enemyAI9 = fq.EnemyAI;
				CentipedeAI val9 = (CentipedeAI)(object)((enemyAI9 is CentipedeAI) ? enemyAI9 : null);
				return (val9 != null && (Object)(object)val9.clingingToPlayer != (Object)null) ? new float?(((Object)(object)val9.clingingToPlayer == (Object)(object)fq.Bot) ? 1f : 15f) : new float?((fq.EnemyAI.currentBehaviourStateIndex > 1) ? 15f : 1f);
			}, delegate(LethalBotFearQuery fq)
			{
				EnemyAI enemyAI8 = fq.EnemyAI;
				CentipedeAI val8 = (CentipedeAI)(object)((enemyAI8 is CentipedeAI) ? enemyAI8 : null);
				return (val8 == null || !((Object)(object)val8.clingingToPlayer == (Object)(object)fq.PlayerToCheck)) ? null : new float?(float.MaxValue);
			}, delegate(LethalBotFearQuery fq)
			{
				float value3;
				if (fq.EnemyAI.currentBehaviourStateIndex <= 1)
				{
					EnemyAI enemyAI7 = fq.EnemyAI;
					CentipedeAI val7 = (CentipedeAI)(object)((enemyAI7 is CentipedeAI) ? enemyAI7 : null);
					if (val7 == null || !((Object)(object)val7.clingingToPlayer != (Object)null))
					{
						value3 = 1f;
						goto IL_0037;
					}
				}
				value3 = 15f;
				goto IL_0037;
				IL_0037:
				return value3;
			});
			RegisterThreat(typeof(SpringManAI), CoilHeadPanikFunc, CoilHeadMissionFunc, (LethalBotFearQuery fq) => (fq.EnemyAI.currentBehaviourStateIndex <= 0) ? null : new float?(20f));
			RegisterThreat(typeof(ButlerEnemyAI), (LethalBotFearQuery fq) => (fq.EnemyAI.currentBehaviourStateIndex != 2) ? null : new float?(20f), (LethalBotFearQuery fq) => (fq.EnemyAI.currentBehaviourStateIndex != 2) ? null : new float?(10f), (LethalBotFearQuery fq) => (fq.EnemyAI.currentBehaviourStateIndex != 2 && (!(fq.Bot is LethalBotAI lethalBotAI6) || !lethalBotAI6.NpcController.Npc.isPlayerAlone)) ? null : new float?(20f));
			RegisterThreat(typeof(HoarderBugAI), (LethalBotFearQuery fq) => (fq.EnemyAI.currentBehaviourStateIndex != 2) ? null : new float?(20f), (LethalBotFearQuery fq) => (fq.EnemyAI.currentBehaviourStateIndex != 2) ? null : new float?(5f), (LethalBotFearQuery fq) => (fq.EnemyAI.currentBehaviourStateIndex != 2) ? null : new float?(20f));
			RegisterThreat(typeof(MaskedPlayerEnemy), delegate(LethalBotFearQuery fq)
			{
				EnemyAI enemyAI6 = fq.EnemyAI;
				MaskedPlayerEnemy val6 = (MaskedPlayerEnemy)(object)((enemyAI6 is MaskedPlayerEnemy) ? enemyAI6 : null);
				bool value2 = default(bool);
				return ((val6 != null && fq.Bot is LethalBotAI lethalBotAI5 && lethalBotAI5.DictKnownMasked.TryGetValue(val6, out value2) && value2) || fq.EnemyAI.creatureAnimator.GetBool("HandsOut")) ? 30f : 15f;
			}, (LethalBotFearQuery _) => 8f, delegate(LethalBotFearQuery fq)
			{
				EnemyAI enemyAI5 = fq.EnemyAI;
				MaskedPlayerEnemy val5 = (MaskedPlayerEnemy)(object)((enemyAI5 is MaskedPlayerEnemy) ? enemyAI5 : null);
				bool value = default(bool);
				return ((val5 != null && fq.Bot is LethalBotAI lethalBotAI4 && lethalBotAI4.DictKnownMasked.TryGetValue(val5, out value) && value) || fq.EnemyAI.creatureAnimator.GetBool("HandsOut")) ? 30f : 15f;
			});
			RegisterThreat(typeof(SandSpiderAI), (LethalBotFearQuery fq) => (fq.EnemyAI.currentBehaviourStateIndex == 2) ? 20f : 5f, (LethalBotFearQuery fq) => (fq.EnemyAI.currentBehaviourStateIndex != 2) ? null : new float?(10f), (LethalBotFearQuery fq) => (fq.EnemyAI.currentBehaviourStateIndex == 2) ? 20f : 10f);
			RegisterThreat(typeof(NutcrackerEnemyAI), NutcrackerPanikFunc, NutcrackerMissionFunc, NutcrackerPanikFunc);
			RegisterThreat(typeof(GiantKiwiAI), GiantKiwiPanikFunc, (LethalBotFearQuery _) => null, (LethalBotFearQuery fq) => (fq.EnemyAI.currentBehaviourStateIndex > 1) ? 30f : 15f);
			RegisterThreat(typeof(DressGirlAI), delegate(LethalBotFearQuery fq)
			{
				EnemyAI enemyAI4 = fq.EnemyAI;
				DressGirlAI val4 = (DressGirlAI)(object)((enemyAI4 is DressGirlAI) ? enemyAI4 : null);
				return (val4 == null || !(fq.Bot is LethalBotAI lethalBotAI3) || !((Object)(object)val4.hauntingPlayer == (Object)(object)lethalBotAI3.NpcController.Npc) || (!val4.staringInHaunt && ((EnemyAI)val4).currentBehaviourStateIndex <= 0)) ? null : new float?(40f);
			}, (LethalBotFearQuery _) => null, delegate(LethalBotFearQuery fq)
			{
				EnemyAI enemyAI3 = fq.EnemyAI;
				DressGirlAI val3 = (DressGirlAI)(object)((enemyAI3 is DressGirlAI) ? enemyAI3 : null);
				return (val3 == null || !(fq.Bot is LethalBotAI lethalBotAI2) || !((Object)(object)val3.hauntingPlayer == (Object)(object)lethalBotAI2.NpcController.Npc) || !val3.staringInHaunt) ? null : new float?(60f);
			});
			static float? CoilHeadMissionFunc(LethalBotFearQuery fearQuery)
			{
				if (fearQuery.EnemyAI.currentBehaviourStateIndex > 0)
				{
					PlayerControllerB playerToCheck = fearQuery.PlayerToCheck;
					if (playerToCheck != null && playerToCheck.timeSincePlayerMoving > 10f)
					{
						return 10f;
					}
				}
				return null;
			}
			static float? CoilHeadPanikFunc(LethalBotFearQuery fearQuery)
			{
				EnemyAI enemyAI2 = fearQuery.EnemyAI;
				SpringManAI val2 = (SpringManAI)(object)((enemyAI2 is SpringManAI) ? enemyAI2 : null);
				if (val2 != null && PatchesUtil.stopMovementTimerField.Invoke(val2) > 10f)
				{
					return null;
				}
				if (fearQuery.EnemyAI.currentBehaviourStateIndex <= 0)
				{
					return null;
				}
				return 20f;
			}
			static float? GiantKiwiPanikFunc(LethalBotFearQuery fearQuery)
			{
				return fearQuery.EnemyAI.currentBehaviourStateIndex switch
				{
					1 => 15f, 
					2 => 30f, 
					_ => 5f, 
				};
			}
			static float? NutcrackerMissionFunc(LethalBotFearQuery fearQuery)
			{
				return 10f;
			}
			static float? NutcrackerPanikFunc(LethalBotFearQuery fearQuery)
			{
				int currentBehaviourStateIndex = fearQuery.EnemyAI.currentBehaviourStateIndex;
				if (currentBehaviourStateIndex != 1)
				{
					if (currentBehaviourStateIndex == 2)
					{
						EnemyAI enemyAI = fearQuery.EnemyAI;
						NutcrackerEnemyAI val = (NutcrackerEnemyAI)(object)((enemyAI is NutcrackerEnemyAI) ? enemyAI : null);
						if (val != null && fearQuery.Bot is LethalBotAI lethalBotAI && val.lastPlayerSeenMoving == (int)lethalBotAI.NpcController.Npc.playerClientId)
						{
							goto IL_004b;
						}
					}
					if (currentBehaviourStateIndex == 2)
					{
						return 30f;
					}
					return 15f;
				}
				goto IL_004b;
				IL_004b:
				return 60f;
			}
		}

		private static void RegisterCustomThreats()
		{
		}

		[ServerRpc(RequireOwnership = false)]
		public void SpawnLethalBotServerRpc(SpawnLethalBotParamsNetworkSerializable spawnLethalBotsParamsNetworkSerializable)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				ServerRpcParams val = default(ServerRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(1499736859u, val, (RpcDelivery)0);
				((FastBufferWriter)(ref val2)).WriteValueSafe<SpawnLethalBotParamsNetworkSerializable>(ref spawnLethalBotsParamsNetworkSerializable, default(ForNetworkSerializable));
				((NetworkBehaviour)this).__endSendServerRpc(ref val2, 1499736859u, val, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage != 1 || (!networkManager.IsServer && !networkManager.IsHost))
			{
				return;
			}
			base.__rpc_exec_stage = (__RpcExecStage)0;
			if (AllLethalBotAIs == null || AllLethalBotAIs.Length == 0)
			{
				Plugin.LogError($"Fatal error : client #{((NetworkBehaviour)this).NetworkManager.LocalClientId} no bots initialized ! Please check for previous errors in the console");
				botSpawned.Value = EnumBotSpawnState.NotSpawned;
				return;
			}
			int num = -1;
			int[] identitiesToDrop = IdentityManager.Instance.GetIdentitiesToDrop();
			if (identitiesToDrop.Length != 0)
			{
				num = identitiesToDrop[0];
			}
			else
			{
				LethalBotIdentity identiyFromIndex = IdentityManager.Instance.GetIdentiyFromIndex(IdentityManager.Instance.GetNewIdentityToSpawn());
				if (identiyFromIndex != null)
				{
					num = identiyFromIndex.IdIdentity;
				}
			}
			if (num < 0)
			{
				Plugin.LogInfo("Try to spawn bot, no more bot identities available.");
				botSpawned.Value = EnumBotSpawnState.NotSpawned;
			}
			else
			{
				IdentityManager.Instance.LethalBotIdentities[num].Status = EnumStatusIdentity.Spawned;
				spawnLethalBotsParamsNetworkSerializable.LethalBotIdentityID = num;
				SpawnLethalBotServer(spawnLethalBotsParamsNetworkSerializable);
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void SpawnThisLethalBotServerRpc(int identityID, SpawnLethalBotParamsNetworkSerializable spawnLethalBotsParamsNetworkSerializable)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				ServerRpcParams val = default(ServerRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(1902467509u, val, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val2, identityID);
				((FastBufferWriter)(ref val2)).WriteValueSafe<SpawnLethalBotParamsNetworkSerializable>(ref spawnLethalBotsParamsNetworkSerializable, default(ForNetworkSerializable));
				((NetworkBehaviour)this).__endSendServerRpc(ref val2, 1902467509u, val, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				if (AllLethalBotAIs == null || AllLethalBotAIs.Length == 0)
				{
					Plugin.LogError($"Fatal error : client #{((NetworkBehaviour)this).NetworkManager.LocalClientId} no bots initialized ! Please check for previous errors in the console.");
					return;
				}
				if (identityID < 0)
				{
					Plugin.LogInfo($"Unknown to spawn specific bot identity with id {identityID}.");
					return;
				}
				spawnLethalBotsParamsNetworkSerializable.LethalBotIdentityID = identityID;
				SpawnLethalBotServer(spawnLethalBotsParamsNetworkSerializable);
			}
		}

		private void SpawnLethalBotServer(SpawnLethalBotParamsNetworkSerializable spawnLethalBotsParamsNetworkSerializable)
		{
			int num = spawnLethalBotsParamsNetworkSerializable.IndexNextPlayerObject ?? GetNextAvailablePlayerObject();
			if (num < 0)
			{
				Plugin.LogInfo($"No more bots can be spawned at the same time, see Max Server size value : {Plugin.PluginIrlPlayersCount}");
				if (((NetworkBehaviour)this).IsServer || ((NetworkBehaviour)this).IsHost)
				{
					botSpawned.Value = EnumBotSpawnState.NotSpawned;
				}
				return;
			}
			LethalBotAI lethalBotAI = AllLethalBotAIs[num];
			NetworkObject val;
			if ((Object)(object)lethalBotAI != (Object)null)
			{
				val = ((NetworkBehaviour)AllLethalBotAIs[num]).NetworkObject;
			}
			else
			{
				GameObject val2 = Object.Instantiate<GameObject>(Plugin.LethalBotNPCPrefab.enemyPrefab);
				lethalBotAI = val2.GetComponent<LethalBotAI>();
				Plugin.LogDebug($"{val2}");
				Plugin.LogDebug($"{lethalBotAI}");
				AllLethalBotAIs[num] = lethalBotAI;
				val = val2.GetComponentInChildren<NetworkObject>();
				val.Spawn(true);
			}
			lethalBotAI.LethalBotIdentity = IdentityManager.Instance.LethalBotIdentities[spawnLethalBotsParamsNetworkSerializable.LethalBotIdentityID];
			int suitID = ((!Plugin.Config.ChangeSuitAutoBehaviour.Value) ? (lethalBotAI.LethalBotIdentity.SuitID ?? lethalBotAI.LethalBotIdentity.GetRandomSuitID()) : GameNetworkManager.Instance.localPlayerController.currentSuitID);
			spawnLethalBotsParamsNetworkSerializable.IndexNextLethalBot = num;
			spawnLethalBotsParamsNetworkSerializable.IndexNextPlayerObject = num;
			spawnLethalBotsParamsNetworkSerializable.LethalBotIdentityID = lethalBotAI.LethalBotIdentity.IdIdentity;
			spawnLethalBotsParamsNetworkSerializable.SuitID = suitID;
			((MonoBehaviour)this).StartCoroutine(WaitBeforeSpawnOnClient(val, spawnLethalBotsParamsNetworkSerializable));
		}

		[IteratorStateMachine(typeof(<WaitBeforeSpawnOnClient>d__114))]
		private IEnumerator WaitBeforeSpawnOnClient(NetworkObject networkObject, SpawnLethalBotParamsNetworkSerializable spawnLethalBotParamsNetworkSerializable)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <WaitBeforeSpawnOnClient>d__114(0)
			{
				<>4__this = this,
				networkObject = networkObject,
				spawnLethalBotParamsNetworkSerializable = spawnLethalBotParamsNetworkSerializable
			};
		}

		internal int GetNextAvailablePlayerObject()
		{
			StartOfRound instance = StartOfRound.Instance;
			int num = instance.allPlayerScripts.Length;
			int num2 = Mathf.Clamp((Plugin.IsModLethalInternsLoaded && IndexBeginOfInterns > 0) ? IndexBeginOfInterns : num, 0, num);
			for (int i = 0; i < num2; i++)
			{
				PlayerControllerB val = instance.allPlayerScripts[i];
				if (!val.isPlayerControlled && !val.isPlayerDead)
				{
					return i;
				}
			}
			return -1;
		}

		[ClientRpc]
		private void SpawnLethalBotClientRpc(NetworkObjectReference networkObjectReferenceLethalBotAI, SpawnLethalBotParamsNetworkSerializable spawnParamsNetworkSerializable)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val = default(ClientRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(4279964955u, val, (RpcDelivery)0);
				((FastBufferWriter)(ref val2)).WriteValueSafe<NetworkObjectReference>(ref networkObjectReferenceLethalBotAI, default(ForNetworkSerializable));
				((FastBufferWriter)(ref val2)).WriteValueSafe<SpawnLethalBotParamsNetworkSerializable>(ref spawnParamsNetworkSerializable, default(ForNetworkSerializable));
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 4279964955u, val, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage != 1 || (!networkManager.IsClient && !networkManager.IsHost))
			{
				return;
			}
			base.__rpc_exec_stage = (__RpcExecStage)0;
			Plugin.LogInfo($"Client receive RPC to spawn bot... position : {spawnParamsNetworkSerializable.SpawnPosition}, yRot: {spawnParamsNetworkSerializable.YRot}");
			if (AllLethalBotAIs == null || AllLethalBotAIs.Length == 0)
			{
				Plugin.LogError($"Fatal error : client #{((NetworkBehaviour)this).NetworkManager.LocalClientId} no bots initialized ! Please check for previous errors in the console");
				if (((NetworkBehaviour)this).IsServer || ((NetworkBehaviour)this).IsHost)
				{
					botSpawned.Value = EnumBotSpawnState.NotSpawned;
				}
				return;
			}
			NetworkObject val3 = default(NetworkObject);
			((NetworkObjectReference)(ref networkObjectReferenceLethalBotAI)).TryGet(ref val3, (NetworkManager)null);
			LethalBotAI component = ((Component)val3).gameObject.GetComponent<LethalBotAI>();
			AllLethalBotAIs[spawnParamsNetworkSerializable.IndexNextLethalBot] = component;
			if (spawnParamsNetworkSerializable.LethalBotIdentityID >= IdentityManager.Instance.LethalBotIdentities.Length)
			{
				IdentityManager.Instance.ExpandWithNewDefaultIdentities(1);
			}
			InitLethalBotSpawning(component, spawnParamsNetworkSerializable);
		}

		private void InitLethalBotSpawning(LethalBotAI lethalBotAI, SpawnLethalBotParamsNetworkSerializable spawnParamsNetworkSerializable, bool clientJoining = false)
		{
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_014b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0155: Expected O, but got Unknown
			//IL_0242: Unknown result type (might be due to invalid IL or missing references)
			//IL_0247: Unknown result type (might be due to invalid IL or missing references)
			//IL_0483: Unknown result type (might be due to invalid IL or missing references)
			//IL_0489: Unknown result type (might be due to invalid IL or missing references)
			//IL_048d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0493: Unknown result type (might be due to invalid IL or missing references)
			//IL_0497: Unknown result type (might be due to invalid IL or missing references)
			//IL_049d: Unknown result type (might be due to invalid IL or missing references)
			//IL_04a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_04a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_04b1: Unknown result type (might be due to invalid IL or missing references)
			StartOfRound instance = StartOfRound.Instance;
			LethalBotIdentity lethalBotIdentity = IdentityManager.Instance.LethalBotIdentities[spawnParamsNetworkSerializable.LethalBotIdentityID];
			if (!spawnParamsNetworkSerializable.IndexNextPlayerObject.HasValue)
			{
				Plugin.LogError($"Fatal error : client #{((NetworkBehaviour)this).NetworkManager.LocalClientId} no indexNextPlayerObject in SpawnLethalBotParamsNetworkSerializable ! Please check for previous errors in the console");
				return;
			}
			GameObject val = instance.allPlayerObjects[spawnParamsNetworkSerializable.IndexNextPlayerObject.Value];
			val.transform.position = (Vector3)(((??)spawnParamsNetworkSerializable.SpawnPosition) ?? StartOfRoundPatch.GetPlayerSpawnPosition_ReversePatch(StartOfRound.Instance, spawnParamsNetworkSerializable.IndexNextPlayerObject.Value, simpleTeleport: false));
			val.transform.rotation = Quaternion.Euler(new Vector3(0f, spawnParamsNetworkSerializable.YRot, 0f));
			PlayerControllerB val2 = instance.allPlayerScripts[spawnParamsNetworkSerializable.IndexNextPlayerObject.Value];
			val2.playerUsername = lethalBotIdentity.Name;
			val2.isPlayerDead = false;
			val2.disconnectedMidGame = false;
			val2.isPlayerControlled = true;
			((Component)val2).transform.localScale = Vector3.one;
			val2.playerSteamId = 0uL;
			val2.playerClientId = (ulong)spawnParamsNetworkSerializable.IndexNextPlayerObject.Value;
			val2.actualClientId = val2.playerClientId + 200000;
			val2.isInElevator = true;
			val2.isInHangarShipRoom = true;
			((EnemyAI)lethalBotAI).isInsidePlayerShip = true;
			val2.parentedToElevatorLastFrame = false;
			val2.playerActions = new PlayerActions();
			val2.health = ((spawnParamsNetworkSerializable.Hp == 0) ? 100 : spawnParamsNetworkSerializable.Hp);
			val2.overridePoisonValue = false;
			val2.carryWeight = spawnParamsNetworkSerializable.CarryWeight.GetValueOrDefault(1f);
			val2.DisablePlayerModel(val, true, true);
			val2.isInsideFactory = !spawnParamsNetworkSerializable.IsOutside;
			val2.isMovementHindered = 0;
			val2.hinderedMultiplier = 1f;
			val2.criticallyInjured = false;
			val2.bleedingHeavily = false;
			val2.activatingItem = false;
			val2.twoHanded = false;
			val2.inSpecialInteractAnimation = false;
			val2.freeRotationInInteractAnimation = false;
			val2.disableSyncInAnimation = false;
			val2.disableLookInput = false;
			val2.inAnimationWithEnemy = null;
			val2.holdingWalkieTalkie = false;
			val2.speakingToWalkieTalkie = false;
			val2.isSinking = false;
			val2.isUnderwater = false;
			val2.sinkingValue = 0f;
			val2.sourcesCausingSinking = 0;
			val2.isClimbingLadder = false;
			val2.setPositionOfDeadPlayer = false;
			val2.mapRadarDotAnimator.SetBool("dead", false);
			val2.externalForceAutoFade = Vector3.zero;
			val2.voiceMuffledByEnemy = false;
			val2.playerBodyAnimator.SetBool("Limp", false);
			((Behaviour)val2.usernameBillboardText).enabled = true;
			if (spawnParamsNetworkSerializable.ResetBodyBlood && spawnParamsNetworkSerializable.enumSpawnAnimation != EnumSpawnAnimation.ReinitializePlayer)
			{
				val2.ResetPlayerBloodObjects(true);
			}
			if (!clientJoining && lethalBotIdentity.JustJoinedServer)
			{
				AccessTools.Field(typeof(PlayerControllerB), "updatePositionForNewlyJoinedClient").SetValue(val2, true);
				HUDManager.Instance.AddTextToChatOnServer(val2.playerUsername + " joined the ship.", -1);
			}
			CleanLegsFromMoreEmotesMod(val2);
			lethalBotAI.BotId = Array.IndexOf(AllLethalBotAIs, lethalBotAI);
			((EnemyAI)lethalBotAI).creatureAnimator = val2.playerBodyAnimator;
			lethalBotAI.NpcController = new NpcController(val2);
			((EnemyAI)lethalBotAI).eye = ((Component)val2).GetComponentsInChildren<Transform>().First((Transform x) => ((Object)x).name == "PlayerEye");
			lethalBotAI.LethalBotIdentity = lethalBotIdentity;
			lethalBotAI.LethalBotIdentity.Hp = ((spawnParamsNetworkSerializable.Hp == 0) ? 100 : spawnParamsNetworkSerializable.Hp);
			lethalBotAI.LethalBotIdentity.SuitID = spawnParamsNetworkSerializable.SuitID;
			lethalBotAI.LethalBotIdentity.Status = EnumStatusIdentity.Spawned;
			lethalBotAI.LethalBotIdentity.JustJoinedServer = false;
			((EnemyAI)lethalBotAI).SetEnemyOutside(spawnParamsNetworkSerializable.IsOutside);
			((Behaviour)lethalBotAI).enabled = true;
			val.SetActive(true);
			if (clientJoining && (Object)(object)val2.currentlyHeldObject != (Object)null)
			{
				lethalBotAI.HeldItem = val2.currentlyHeldObject;
			}
			PlayerControllerBPatch.OnDisable_ReversePatch(val2);
			if (spawnParamsNetworkSerializable.ShouldDestroyDeadBody)
			{
				if (Plugin.IsModModelReplacementAPILoaded && lethalBotIdentity.BodyReplacementBase != null)
				{
					RemovePlayerModelReplacement(lethalBotIdentity.BodyReplacementBase);
					lethalBotIdentity.BodyReplacementBase = null;
				}
				DeadBodyInfo val3 = lethalBotIdentity.DeadBody ?? val2.deadBody;
				if ((Object)(object)val3 != (Object)null)
				{
					GrabbableObject grabBodyObject = val3.grabBodyObject;
					if ((Object)(object)grabBodyObject != (Object)null)
					{
						if (!grabBodyObject.isHeld)
						{
							if (((NetworkBehaviour)this).IsServer)
							{
								if (((NetworkBehaviour)grabBodyObject).NetworkObject.IsSpawned)
								{
									((NetworkBehaviour)grabBodyObject).NetworkObject.Despawn(true);
								}
								else
								{
									Object.Destroy((Object)(object)((Component)grabBodyObject).gameObject);
								}
							}
						}
						else
						{
							PlayerControllerB playerHeldBy = grabBodyObject.playerHeldBy;
							if ((Object)(object)playerHeldBy != (Object)null && grabBodyObject.isHeld)
							{
								playerHeldBy.DropAllHeldItems(true, false, false, false, default(Vector3), default(Vector3), default(Vector3), default(Vector3), default(Vector3));
							}
						}
					}
					Object.Destroy((Object)(object)((Component)val3).gameObject);
					lethalBotIdentity.DeadBody = null;
				}
			}
			if ((Object)(object)val2.deadBody != (Object)null)
			{
				val2.deadBody = null;
			}
			bool playAudio = !clientJoining;
			lethalBotAI.ChangeSuitLethalBot(val2.playerClientId, lethalBotAI.LethalBotIdentity.SuitID.Value, playAudio);
			if (Plugin.IsModModelReplacementAPILoaded)
			{
				lethalBotAI.HideShowModelReplacement(show: true);
			}
			if (Plugin.IsModLethalPhonesLoaded)
			{
				SetupLethalPhoneForBot(val2);
			}
			val2.quickMenuManager.AddUserToPlayerList(0uL, val2.playerUsername, (int)val2.playerClientId);
			val2.quickMenuManager.playerListSlots[val2.playerClientId].volumeSlider.normalizedValue = lethalBotAI.LethalBotIdentity.Voice.Volume;
			if (Plugin.IsModGeneralImprovementsLoaded && IsGeneralImprovementsPlayerNodesActive())
			{
				ScanNodeProperties componentInChildren = ((Component)val2).GetComponentInChildren<ScanNodeProperties>();
				if ((Object)(object)componentInChildren != (Object)null)
				{
					componentInChildren.headerText = val2.playerUsername;
				}
			}
			if (Plugin.IsModMoreCompanyLoaded)
			{
				SetupMoreCompanyCosmetics(lethalBotIdentity, val2);
			}
			instance.mapScreen.radarTargets[(int)val2.playerClientId].name = val2.playerUsername;
			if (GameNetworkManager.Instance.localPlayerController.isPlayerDead)
			{
				val2.isPlayerControlled = false;
				try
				{
					HUDManager.Instance.UpdateBoxesSpectateUI();
				}
				finally
				{
					val2.isPlayerControlled = true;
				}
			}
			StartOfRound.Instance.ClientPlayerList[val2.actualClientId] = (int)val2.playerClientId;
			if (((NetworkBehaviour)this).IsServer || ((NetworkBehaviour)this).IsHost)
			{
				HUDManager.Instance.SyncPlayerLevelServerRpc((int)val2.playerClientId, lethalBotAI.LethalBotIdentity.Level, true);
				if (isSpawningBots.Value)
				{
					botSpawned.Value = EnumBotSpawnState.Spawned;
				}
				else
				{
					sendPlayerCountUpdate.Value = true;
				}
			}
			Plugin.LogDebug($"++ Bot with body {val2.playerClientId} with identity spawned: {lethalBotIdentity.ToString()}");
			lethalBotAI.Init(spawnParamsNetworkSerializable.enumSpawnAnimation, clientJoining);
		}

		[ServerRpc(RequireOwnership = false)]
		private void ReinitSpawnedBotServerRpc(NetworkObjectReference networkObjectReferenceLethalBotAI)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val = default(ServerRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(1204273602u, val, (RpcDelivery)0);
					((FastBufferWriter)(ref val2)).WriteValueSafe<NetworkObjectReference>(ref networkObjectReferenceLethalBotAI, default(ForNetworkSerializable));
					((NetworkBehaviour)this).__endSendServerRpc(ref val2, 1204273602u, val, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					ReinitSpawnedBotClientRpc(networkObjectReferenceLethalBotAI);
				}
			}
		}

		[ClientRpc]
		private void ReinitSpawnedBotClientRpc(NetworkObjectReference networkObjectReferenceLethalBotAI)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val = default(ClientRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(1169342065u, val, (RpcDelivery)0);
				((FastBufferWriter)(ref val2)).WriteValueSafe<NetworkObjectReference>(ref networkObjectReferenceLethalBotAI, default(ForNetworkSerializable));
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 1169342065u, val, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				NetworkObject val3 = default(NetworkObject);
				if (((NetworkObjectReference)(ref networkObjectReferenceLethalBotAI)).TryGet(ref val3, (NetworkManager)null))
				{
					LethalBotAI component = ((Component)val3).gameObject.GetComponent<LethalBotAI>();
					ReinitSpawnedBot(component);
				}
				else
				{
					Plugin.LogError("ReinitSpawnedBotClientRpc was provided with an invalid LethalBotAI network object reference.");
				}
			}
		}

		private void ReinitSpawnedBot(LethalBotAI lethalBotAI)
		{
			PlayerControllerB npc = lethalBotAI.NpcController.Npc;
			npc.isInElevator = true;
			npc.isInHangarShipRoom = true;
			((EnemyAI)lethalBotAI).isInsidePlayerShip = true;
			lethalBotAI.LethalBotIdentity.Hp = npc.health;
			((EnemyAI)lethalBotAI).SetEnemyOutside(true);
			Plugin.LogDebug($"++ Bot with body {npc.playerClientId} with identity reinitialized: {lethalBotAI.LethalBotIdentity.ToString()}");
			lethalBotAI.Init(EnumSpawnAnimation.ReinitializePlayer);
		}

		private bool IsGeneralImprovementsPlayerNodesActive()
		{
			return Plugin.ScanPlayers.Value;
		}

		private void SetupLethalPhoneForBot(PlayerControllerB lethalBotController)
		{
			if (!((NetworkBehaviour)lethalBotController).IsOwner)
			{
				return;
			}
			PlayerPhonePatch.PhoneManager = PhoneNetworkHandler.Instance;
			PhoneBehavior component = ((Component)((Component)lethalBotController).transform.Find("PhonePrefab(Clone)")).GetComponent<PhoneBehavior>();
			if (!PhoneNetworkHandler.allPhoneBehaviors.Contains(component))
			{
				PlayerPhonePatch.PhoneManager.CreateNewPhone(((NetworkBehaviour)component).NetworkObjectId, "lethalphones.customizations.default", "lethalphones.customizations.default", "lethalphones.customizations.default");
				if ((Object)(object)GameNetworkManager.Instance.localPlayerController == (Object)(object)lethalBotController)
				{
					component.playPos = lethalBotController.playerGlobalHead;
					component.recordPos = lethalBotController.localArmsTransform.Find("shoulder.L/arm.L_upper/arm.L_lower/hand.L/LocalPhoneModel(Clone)");
				}
				else
				{
					component.playPos = lethalBotController.lowerSpine.Find("spine.002/spine.003/shoulder.L/arm.L_upper/arm.L_lower/hand.L/ServerPhoneModel(Clone)");
					component.recordPos = lethalBotController.lowerSpine.Find("spine.002/spine.003/shoulder.L/arm.L_upper/arm.L_lower/hand.L/ServerPhoneModel(Clone)");
				}
				PlayerPhone val = (PlayerPhone)(object)((component is PlayerPhone) ? component : null);
				if (val != null)
				{
					((MonoBehaviour)this).StartCoroutine(togglePhoneModelAfterSpawn((NetworkBehaviour)(object)val, lethalBotController.playerUsername));
				}
			}
		}

		[IteratorStateMachine(typeof(<togglePhoneModelAfterSpawn>d__123))]
		private IEnumerator togglePhoneModelAfterSpawn(NetworkBehaviour playerPhoneNetworkBehavior, string botName)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <togglePhoneModelAfterSpawn>d__123(0)
			{
				playerPhoneNetworkBehavior = playerPhoneNetworkBehavior,
				botName = botName
			};
		}

		private void CleanupLethalPhoneForBot(int lethalBotControllerId)
		{
			if (((NetworkBehaviour)this).IsHost && ((NetworkBehaviour)this).IsServer)
			{
				PhoneNetworkHandler.Instance.DeletePlayerPhone(lethalBotControllerId);
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private void CleanupLethalPhoneForBot(PlayerControllerB lethalBotController)
		{
			CleanupLethalPhoneForBot((int)lethalBotController.playerClientId);
		}

		private void SetupMoreCompanyCosmetics(LethalBotIdentity lethalBotIdentity, PlayerControllerB lethalBotController)
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			if (((NetworkBehaviour)lethalBotController).IsOwner)
			{
				string moreCompanyCosmetics = lethalBotIdentity.MoreCompanyCosmetics;
				string[] array = moreCompanyCosmetics.Split(',');
				int num = FastBufferWriter.GetWriteSize<ulong>(ref lethalBotController.playerClientId, default(ForStructs)) + FastBufferWriter.GetWriteSize(moreCompanyCosmetics, false);
				bool flag = false;
				int num2 = num + FastBufferWriter.GetWriteSize<bool>(ref flag, default(ForStructs));
				FastBufferWriter val = default(FastBufferWriter);
				((FastBufferWriter)(ref val))..ctor(num2, (Allocator)2, -1);
				FastBufferWriter val2 = val;
				try
				{
					((FastBufferWriter)(ref val)).WriteValueSafe<ulong>(ref lethalBotController.playerClientId, default(ForPrimitives));
					((FastBufferWriter)(ref val)).WriteValueSafe(moreCompanyCosmetics, false);
					flag = false;
					((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
					NetworkManager.Singleton.CustomMessagingManager.SendNamedMessage("MC_SV_SyncCosmetics", 0uL, val, (NetworkDelivery)((((FastBufferWriter)(ref val)).Capacity > 1300) ? 4 : 2));
				}
				finally
				{
					((IDisposable)(FastBufferWriter)(ref val2)).Dispose();
				}
				Plugin.LogInfo("Lethal Bot: " + lethalBotController.playerUsername + " is sending cosmetics to the server.");
				MainClass.StaticLogger.LogInfo((object)$"Sending {array.Length} cosmetics to the server | Request All: {false}");
			}
		}

		public void OnLethalBotKicked(LethalBotAI lethalBotAI)
		{
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			int num = Array.IndexOf(AllLethalBotAIs, lethalBotAI);
			if (num < 0)
			{
				Plugin.LogError($"Fatal error : client #{((NetworkBehaviour)this).NetworkManager.LocalClientId} lethal bot AI not found in AllLethalBotAIs array ! Please check for previous errors in the console");
			}
			else
			{
				LethalBotKickedServerRpc(num);
			}
		}

		private void HandleLethalBotKicked(LethalBotAI lethalBotAI)
		{
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_0140: Unknown result type (might be due to invalid IL or missing references)
			//IL_0186: Unknown result type (might be due to invalid IL or missing references)
			PlayerControllerB val = lethalBotAI.NpcController?.Npc;
			if (!((Object)(object)val != (Object)null))
			{
				return;
			}
			StartOfRound instance = StartOfRound.Instance;
			if (!val.isPlayerControlled && !val.isPlayerDead)
			{
				Plugin.LogWarning("Lethal bot " + val.playerUsername + " is being kicked but is not player controlled and is not dead!");
				return;
			}
			if (((NetworkBehaviour)this).IsServer)
			{
				HUDManager.Instance.AddTextToChatOnServer($"[playerNum{val.playerClientId}] was kicked.", -1);
			}
			if (val.inTerminalMenu)
			{
				lethalBotAI.LeaveTerminal();
			}
			lethalBotAI.NpcController?.StopPreformingEmote(forceStop: true);
			val.DropAllHeldItems(true, true, false, false, default(Vector3), default(Vector3), default(Vector3), default(Vector3), default(Vector3));
			lethalBotAI.LethalBotIdentity.Status = EnumStatusIdentity.ToSpawn;
			lethalBotAI.LethalBotIdentity.DiedLastRound = true;
			lethalBotAI.LethalBotIdentity.JustJoinedServer = true;
			if (lethalBotAI.State != null && lethalBotAI.State.GetAIState() != 0)
			{
				lethalBotAI.State = new BrainDeadState(lethalBotAI);
			}
			val.TeleportPlayer(instance.notSpawnedPosition.position, false, 0f, false, true);
			val.localVisor.position = instance.notSpawnedPosition.position;
			val.DisablePlayerModel(((Component)val).gameObject, true, true);
			Animator playerBodyAnimator = val.playerBodyAnimator;
			if ((Object)(object)playerBodyAnimator != (Object)null)
			{
				playerBodyAnimator.Rebind(true);
				playerBodyAnimator.Update(0f);
			}
			((Component)val).transform.position = instance.notSpawnedPosition.position;
			((Collider)val.thisController).enabled = false;
			if (!NetworkManager.Singleton.ShutdownInProgress && ((NetworkBehaviour)this).IsServer)
			{
				((Component)val).gameObject.GetComponent<NetworkObject>().RemoveOwnership();
			}
			QuickMenuManager val2 = Object.FindObjectOfType<QuickMenuManager>();
			if ((Object)(object)val2 != (Object)null)
			{
				val2.RemoveUserFromPlayerList((int)val.playerClientId);
			}
			if (!val.isPlayerDead)
			{
				instance.livingPlayers--;
				if (((NetworkBehaviour)this).IsServer)
				{
					((UnityEvent<PlayerControllerB, int>)(object)StartOfRound.Instance.LocalPlayerDieEvent).Invoke(val, 200);
				}
			}
			instance.connectedPlayersAmount--;
			val.isPlayerControlled = false;
			val.isPlayerDead = false;
			if (!instance.inShipPhase)
			{
				val.disconnectedMidGame = true;
				if (instance.livingPlayers == 0)
				{
					instance.allPlayersDead = true;
					instance.ShipLeaveAutomatically(false);
				}
			}
			if (Plugin.IsModLethalPhonesLoaded)
			{
				lethalBotAI.StopBeingSwitchboardOperator();
				if (lethalBotAI.AreWeInCall() || lethalBotAI.IsPhoneEquipped())
				{
					lethalBotAI.HangupPhone();
				}
				CleanupLethalPhoneForBot(val);
			}
			if (Plugin.IsModAutoReviveLoaded)
			{
				LethalBotAutoReviveHelper.AutoReviveHandler autoReviveHandler = LethalBotAutoReviveHelper.GetAutoReviveHandler(val);
				autoReviveHandler.OnPlayerDC();
			}
			UnlockableSuit.SwitchSuitForPlayer(val, 0, false);
			if (GameNetworkManager.Instance.localPlayerController.isPlayerDead)
			{
				HUDManager.Instance.UpdateBoxesSpectateUI();
			}
			if (((NetworkBehaviour)this).IsOwner)
			{
				GroupManager.Instance.RemoveFromCurrentGroupAndSync(val);
			}
			ulong actualClientId = val.actualClientId;
			StartOfRound.Instance.ClientPlayerList.Remove(actualClientId);
			if (instance.fullyLoadedPlayers.Contains(actualClientId))
			{
				instance.fullyLoadedPlayers.Remove(actualClientId);
			}
			if (RoundManager.Instance.playersFinishedGeneratingFloor.Contains(actualClientId))
			{
				RoundManager.Instance.playersFinishedGeneratingFloor.Remove(actualClientId);
			}
			if (GameNetworkManager.Instance.disableSteam)
			{
				string text = (val.playerUsername = $"Player #{val.playerClientId}");
				((TMP_Text)val.usernameBillboardText).text = text;
				StartOfRound.Instance.mapScreen.radarTargets[(int)val.playerClientId].name = text;
			}
			if (((NetworkBehaviour)this).IsServer)
			{
				NetworkObject networkObject = ((NetworkBehaviour)lethalBotAI).NetworkObject;
				if ((Object)(object)networkObject != (Object)null && networkObject.IsSpawned)
				{
					Plugin.LogDebug("Despawning kicked bot LethalBotAI object");
					networkObject.Despawn(true);
				}
				else
				{
					Plugin.LogWarning("Kicked bot LethalBotAI object was not spawned? Manually removing.");
					Object.Destroy((Object)(object)((Component)lethalBotAI).gameObject);
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		private void LethalBotKickedServerRpc(int indexLethalBotAI, ServerRpcParams rpcParams = default(ServerRpcParams))
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(3450665584u, rpcParams, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val, indexLethalBotAI);
				((NetworkBehaviour)this).__endSendServerRpc(ref val, 3450665584u, rpcParams, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage != 1 || (!networkManager.IsServer && !networkManager.IsHost))
			{
				return;
			}
			base.__rpc_exec_stage = (__RpcExecStage)0;
			if (rpcParams.Receive.SenderClientId != 0L)
			{
				Plugin.LogWarning($"Unauthorized client {rpcParams.Receive.SenderClientId} attempted to kick bot!");
				return;
			}
			if (AllLethalBotAIs == null || AllLethalBotAIs.Length == 0)
			{
				Plugin.LogError($"Fatal error : client #{((NetworkBehaviour)this).NetworkManager.LocalClientId} no bots initialized ! Please check for previous errors in the console");
				return;
			}
			LethalBotAI lethalBotAI = AllLethalBotAIs[indexLethalBotAI];
			if ((Object)(object)lethalBotAI != (Object)null)
			{
				LethalBotKickedClientRpc(indexLethalBotAI);
			}
		}

		[ClientRpc]
		private void LethalBotKickedClientRpc(int indexLethalBotAI)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val = default(ClientRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(1393535500u, val, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val2, indexLethalBotAI);
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 1393535500u, val, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage != 1 || (!networkManager.IsClient && !networkManager.IsHost))
			{
				return;
			}
			base.__rpc_exec_stage = (__RpcExecStage)0;
			if (AllLethalBotAIs == null || AllLethalBotAIs.Length == 0)
			{
				Plugin.LogError($"Fatal error : client #{((NetworkBehaviour)this).NetworkManager.LocalClientId} no bots initialized ! Please check for previous errors in the console");
				return;
			}
			LethalBotAI lethalBotAI = AllLethalBotAIs[indexLethalBotAI];
			if ((Object)(object)lethalBotAI != (Object)null)
			{
				HandleLethalBotKicked(lethalBotAI);
			}
		}

		private void CleanLegsFromMoreEmotesMod(PlayerControllerB lethalBotController)
		{
			Transform obj = ((Component)lethalBotController.playerBodyAnimator).transform.Find("FistPersonLegs");
			GameObject val = ((obj != null) ? ((Component)obj).gameObject : null);
			if ((Object)(object)val != (Object)null)
			{
				Plugin.LogDebug(lethalBotController.playerUsername + ": Cleaning legs from more emotes");
				Object.Destroy((Object)(object)val);
			}
		}

		public void LethalBotsRespondToSignalTranslator(string message)
		{
			message = message.Trim().ToLower();
			LethalBotAI[] allLethalBotAIs = AllLethalBotAIs;
			foreach (LethalBotAI lethalBotAI in allLethalBotAIs)
			{
				if (!((Object)(object)lethalBotAI == (Object)null) && lethalBotAI.NpcController.Npc.isPlayerControlled && lethalBotAI.State != null)
				{
					Plugin.LogDebug("Bot " + lethalBotAI.NpcController.Npc.playerUsername + " recevied message " + message + "!");
					SignalTranslatorCommandsManager.OnSignalTranslatorMessageReceived(lethalBotAI.State, message);
				}
			}
		}

		public void LethalBotsRespondToChatMessage(string message, int playerId)
		{
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_03fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0226: Unknown result type (might be due to invalid IL or missing references)
			//IL_022d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0233: Unknown result type (might be due to invalid IL or missing references)
			//IL_042d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0436: Unknown result type (might be due to invalid IL or missing references)
			//IL_043b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0440: Unknown result type (might be due to invalid IL or missing references)
			//IL_044b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0377: Unknown result type (might be due to invalid IL or missing references)
			//IL_037e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0384: Unknown result type (might be due to invalid IL or missing references)
			//IL_0459: Unknown result type (might be due to invalid IL or missing references)
			//IL_0460: Unknown result type (might be due to invalid IL or missing references)
			//IL_05ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_05f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_05fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0602: Unknown result type (might be due to invalid IL or missing references)
			//IL_04c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_0215: Unknown result type (might be due to invalid IL or missing references)
			//IL_021b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0366: Unknown result type (might be due to invalid IL or missing references)
			//IL_036c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0326: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0336: Unknown result type (might be due to invalid IL or missing references)
			message = message.Trim().ToLower();
			StartOfRound instance = StartOfRound.Instance;
			PlayerControllerB val = instance.allPlayerScripts[playerId];
			if (!IsPlayerLethalBot(val))
			{
				if (message.Contains("i will man the ship"))
				{
					if (IsPlayerLocal(val))
					{
						MissionControlPlayer = val;
					}
					return;
				}
				if (message.Contains("i will transfer loot"))
				{
					if (IsPlayerLocal(val))
					{
						AddPlayerToLootTransferListAndSync(NetworkBehaviourReference.op_Implicit((NetworkBehaviour)(object)val));
					}
					return;
				}
				if (message.StartsWith("!lb addbots"))
				{
					if ((Object)(object)HostPlayerScript != (Object)(object)val)
					{
						HUDManager.Instance.AddTextToChatOnServer("Only the host can add bots!", -1);
					}
					else if (AreWeInOrbit() && Plugin.Config.AllowBotsInOrbit.Value)
					{
						EnsureShipNavMeshBuilt();
						EnableShipNavMesh();
						SpawnLethalBotsAtShip(markBotsAsLoaded: true);
					}
					else
					{
						string text = (Plugin.Config.AllowBotsInOrbit.Value ? "You can only manually add bots in orbit!" : "You have disabled bots in orbit!");
						HUDManager.Instance.AddTextToChatOnServer(text, -1);
					}
					return;
				}
				if (message.StartsWith("!lb blacklistitem"))
				{
					if (!IsPlayerLocal(val))
					{
						return;
					}
					GrabbableObject currentlyHeldObjectServer = val.currentlyHeldObjectServer;
					NetworkObject val2 = ((currentlyHeldObjectServer != null) ? ((NetworkBehaviour)currentlyHeldObjectServer).NetworkObject : null);
					if (!((Object)(object)currentlyHeldObjectServer != (Object)null) || !((Object)(object)val2 != (Object)null) || !val2.IsSpawned)
					{
						return;
					}
					if (message.Contains("all"))
					{
						List<NetworkObjectReference> list = new List<NetworkObjectReference>();
						string itemName = currentlyHeldObjectServer.itemProperties.itemName;
						foreach (GameObject item in grabbableObjectsInMap)
						{
							GrabbableObject val3 = ((item != null) ? item.GetComponent<GrabbableObject>() : null);
							if ((Object)(object)val3 != (Object)null && val3.itemProperties.itemName == itemName)
							{
								NetworkObject val4 = ((val3 != null) ? ((NetworkBehaviour)val3).NetworkObject : null);
								if ((Object)(object)val4 != (Object)null && val4.IsSpawned && !list.Contains(NetworkObjectReference.op_Implicit(val4)))
								{
									list.Add(NetworkObjectReference.op_Implicit(val4));
								}
							}
						}
						RegisterItemsAsBlacklistedServerRpc(list.ToArray());
					}
					else
					{
						RegisterItemAsBlacklistedServerRpc(NetworkObjectReference.op_Implicit(val2));
					}
					return;
				}
				if (message.StartsWith("!lb unblacklistitem"))
				{
					if (!IsPlayerLocal(val))
					{
						return;
					}
					GrabbableObject currentlyHeldObjectServer2 = val.currentlyHeldObjectServer;
					NetworkObject val5 = ((currentlyHeldObjectServer2 != null) ? ((NetworkBehaviour)currentlyHeldObjectServer2).NetworkObject : null);
					if (!((Object)(object)currentlyHeldObjectServer2 != (Object)null) || !((Object)(object)val5 != (Object)null) || !val5.IsSpawned)
					{
						return;
					}
					if (message.Contains("all"))
					{
						List<NetworkObjectReference> list2 = new List<NetworkObjectReference>();
						string itemName2 = currentlyHeldObjectServer2.itemProperties.itemName;
						foreach (GameObject item2 in grabbableObjectsInMap)
						{
							GrabbableObject val6 = ((item2 != null) ? item2.GetComponent<GrabbableObject>() : null);
							if ((Object)(object)val6 != (Object)null && val6.itemProperties.itemName == itemName2)
							{
								NetworkObject val7 = ((val6 != null) ? ((NetworkBehaviour)val6).NetworkObject : null);
								if ((Object)(object)val7 != (Object)null && val7.IsSpawned && !list2.Contains(NetworkObjectReference.op_Implicit(val7)))
								{
									list2.Add(NetworkObjectReference.op_Implicit(val7));
								}
							}
						}
						RemoveItemsFromBlacklistServerRpc(list2.ToArray());
					}
					else
					{
						RemoveItemFromBlacklistServerRpc(NetworkObjectReference.op_Implicit(val5));
					}
					return;
				}
				if (message.Contains("create group"))
				{
					if (IsPlayerLocal(val))
					{
						GroupManager.Instance.CreateGroupAndSync(val);
					}
					return;
				}
				if (message.Contains("leave group"))
				{
					if (IsPlayerLocal(val) && GroupManager.Instance.IsPlayerInGroup(val))
					{
						GroupManager.Instance.RemoveFromCurrentGroupAndSync(val);
					}
					return;
				}
				if (message.Contains("light level"))
				{
					Vector3 position = ((Component)val.gameplayCamera).transform.position;
					float num = 0f;
					int num2 = 0;
					foreach (Light item3 in LightsOnMap)
					{
						if (LethalBotAI.ShouldIgnoreLightSource(item3))
						{
							continue;
						}
						Vector3 val8 = position - ((Component)item3).transform.position;
						float num3 = 1f;
						if ((int)item3.type == 0)
						{
							float num4 = Vector3.Angle(((Component)item3).transform.forward, ((Vector3)(ref val8)).normalized);
							float num5 = item3.spotAngle * 0.5f;
							if (num4 > num5)
							{
								continue;
							}
							num3 = Mathf.Clamp01(num3 - num4 / num5);
						}
						float magnitude = ((Vector3)(ref val8)).magnitude;
						if (!(magnitude > item3.range))
						{
							float num6 = 1f - Mathf.Clamp01(magnitude / item3.range);
							num6 *= num6;
							float lightOcclusionFactor = LethalBotAI.GetLightOcclusionFactor(((Component)item3).transform.position, position);
							num += item3.intensity * num6 * num3 * lightOcclusionFactor;
							num2++;
						}
					}
					HUDManager.Instance.AddTextToChatOnServer($"Light level is {num / (float)((num2 <= 0) ? 1 : num2)}", -1);
					return;
				}
			}
			LethalBotAI[] allLethalBotAIs = AllLethalBotAIs;
			foreach (LethalBotAI lethalBotAI in allLethalBotAIs)
			{
				PlayerControllerB val9 = lethalBotAI?.NpcController?.Npc;
				if ((Object)(object)lethalBotAI == (Object)null || (Object)(object)val9 == (Object)null || !val9.isPlayerControlled || lethalBotAI.State == null || val9.isPlayerDead != val.isPlayerDead || (Object)(object)val9 == (Object)(object)val)
				{
					continue;
				}
				bool flag = val9.holdingWalkieTalkie && val.holdingWalkieTalkie;
				if (!flag && Plugin.IsModLethalPhonesLoaded)
				{
					flag = LethalPhonesCanBotsHearPlayer(val9, val);
				}
				if (!flag)
				{
					Vector3 val10 = ((Component)val9).transform.position - ((Component)val).transform.position;
					if (!(((Vector3)(ref val10)).sqrMagnitude <= 625f))
					{
						continue;
					}
				}
				Plugin.LogDebug("Bot " + val9.playerUsername + " saw message " + message + " from " + val.playerUsername + "!");
				ChatCommandsManager.OnPlayerChatMessageReceived(lethalBotAI.State, message, val, isVoice: false);
			}
		}

		public void LethalBotsRespondToVoiceChat(string message, PlayerControllerB playerWhoSaidMessage)
		{
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			message = message.Trim().ToLower();
			LethalBotAI[] allLethalBotAIs = AllLethalBotAIs;
			foreach (LethalBotAI lethalBotAI in allLethalBotAIs)
			{
				PlayerControllerB val = lethalBotAI?.NpcController?.Npc;
				if ((Object)(object)lethalBotAI == (Object)null || (Object)(object)val == (Object)null || !val.isPlayerControlled || lethalBotAI.State == null || val.isPlayerDead != playerWhoSaidMessage.isPlayerDead || (Object)(object)val == (Object)(object)playerWhoSaidMessage)
				{
					continue;
				}
				bool flag = val.holdingWalkieTalkie && playerWhoSaidMessage.speakingToWalkieTalkie;
				if (!flag && Plugin.IsModLethalPhonesLoaded)
				{
					flag = LethalPhonesCanBotsHearPlayer(val, playerWhoSaidMessage);
				}
				if (!flag)
				{
					Vector3 val2 = ((Component)val).transform.position - ((Component)playerWhoSaidMessage).transform.position;
					if (!(((Vector3)(ref val2)).sqrMagnitude <= 1600f))
					{
						continue;
					}
				}
				Plugin.LogDebug("Bot " + val.playerUsername + " heard message " + message + " from " + playerWhoSaidMessage.playerUsername + "!");
				ChatCommandsManager.OnPlayerChatMessageReceived(lethalBotAI.State, message, playerWhoSaidMessage, isVoice: true);
			}
		}

		public void TransmitVoiceChatAndSync(string message, int playerId)
		{
			if (((NetworkBehaviour)this).IsServer)
			{
				TransmitVoiceChatToAllClientsClientRpc(message, playerId);
			}
			else
			{
				TransmitVoiceChatToAllClientsServerRpc(message, playerId);
			}
		}

		[ServerRpc(RequireOwnership = false)]
		private void TransmitVoiceChatToAllClientsServerRpc(string message, int playerId)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: 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_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				ServerRpcParams val = default(ServerRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(964754010u, val, (RpcDelivery)0);
				bool flag = message != null;
				((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				if (flag)
				{
					((FastBufferWriter)(ref val2)).WriteValueSafe(message, false);
				}
				BytePacker.WriteValueBitPacked(val2, playerId);
				((NetworkBehaviour)this).__endSendServerRpc(ref val2, 964754010u, val, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				TransmitVoiceChatToAllClientsClientRpc(message, playerId);
			}
		}

		[ClientRpc]
		private void TransmitVoiceChatToAllClientsClientRpc(string message, int playerId)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: 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_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val = default(ClientRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(1045654173u, val, (RpcDelivery)0);
				bool flag = message != null;
				((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				if (flag)
				{
					((FastBufferWriter)(ref val2)).WriteValueSafe(message, false);
				}
				BytePacker.WriteValueBitPacked(val2, playerId);
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 1045654173u, val, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				StartOfRound instance = StartOfRound.Instance;
				PlayerControllerB val3 = instance.allPlayerScripts[playerId];
				if ((Object)(object)val3 == (Object)null)
				{
					Plugin.LogWarning($"TransmitVoiceChatToAllClientsClientRpc: playerWhoSaidMessage is null for playerId {playerId}!");
				}
				else
				{
					LethalBotsRespondToVoiceChat(message, val3);
				}
			}
		}

		private static void RegisterVoiceCommands()
		{
			string[] ValidCommands;
			if (!registeredVoiceCommands && Plugin.IsModSpeechRecognitionAPILoaded)
			{
				ValidCommands = ChatCommandsManager.GetAllRegisteredChatCommandKeywords();
				Speech.RegisterPhrases(ValidCommands);
				Speech.RegisterCustomHandler((EventHandler<SpeechEventArgs>)handler);
				registeredVoiceCommands = true;
			}
			void handler(object speechInstance, SpeechEventArgs text)
			{
				if (Plugin.Config.AllowVoiceRecognition.Value)
				{
					PlayerControllerB val = GameNetworkManager.Instance?.localPlayerController;
					if ((Object)(object)val != (Object)null && Speech.IsAboveThreshold(ValidCommands, (double)Plugin.Config.VoiceRecognitionSimilarityThreshold.Value))
					{
						Instance?.TransmitVoiceChatAndSync(Speech.bestMatch, (int)val.playerClientId);
					}
				}
			}
		}

		private static void RegisterDefaultCommands()
		{
			ChatCommandsManager.RemoveAllChatCommands();
			SignalTranslatorCommandsManager.RemoveAllSignalTranslatorCommands();
			AIState.RegisterChatCommands();
			TransferLootState.RegisterChatCommands();
			BrainDeadState.RegisterChatCommands();
			ChillWithPlayerState.RegisterChatCommands();
			MissionControlState.RegisterChatCommands();
			PanikState.RegisterChatCommands();
			AIState.RegisterSignalTranslatorCommands();
			BrainDeadState.RegisterSignalTranslatorCommands();
			ReturnToShipState.RegisterSignalTranslatorCommands();
			ChillAtShipState.RegisterSignalTranslatorCommands();
			ChillWithPlayerState.RegisterSignalTranslatorCommands();
			GetCloseToPlayerState.RegisterSignalTranslatorCommands();
			PlayerInCruiserState.RegisterSignalTranslatorCommands();
			JustLostPlayerState.RegisterSignalTranslatorCommands();
			MissionControlState.RegisterSignalTranslatorCommands();
			PanikState.RegisterSignalTranslatorCommands();
			FightEnemyState.RegisterSignalTranslatorCommands();
			UseKeyOnLockedDoorState.RegisterSignalTranslatorCommands();
		}

		private static void RegisterCustomCommands()
		{
		}

		private static bool LethalPhonesCanBotsHearPlayer(PlayerControllerB botController, PlayerControllerB player)
		{
			Transform obj = ((Component)player).transform.Find("PhonePrefab(Clone)");
			PhoneBehavior val = ((obj != null) ? ((Component)obj).GetComponent<PhoneBehavior>() : null);
			Transform obj2 = ((Component)botController).transform.Find("PhonePrefab(Clone)");
			PhoneBehavior val2 = ((obj2 != null) ? ((Component)obj2).GetComponent<PhoneBehavior>() : null);
			if ((Object)(object)val == (Object)null || (Object)(object)val2 == (Object)null)
			{
				return false;
			}
			PhoneBehavior callerPhone = val.GetCallerPhone();
			SwitchboardPhone val3 = (SwitchboardPhone)(object)((callerPhone is SwitchboardPhone) ? callerPhone : null);
			if ((Object)(object)val3 == (Object)null)
			{
				PhoneBehavior callerPhone2 = val2.GetCallerPhone();
				val3 = (SwitchboardPhone)(object)((callerPhone2 is SwitchboardPhone) ? callerPhone2 : null);
			}
			if ((Object)(object)val2.GetCallerPhone() == (Object)(object)val || ((Object)(object)val3 != (Object)null && (((Object)(object)val3.switchboardOperator == (Object)(object)player && (Object)(object)val2.GetCallerPhone() == (Object)(object)val3) || ((Object)(object)val3.switchboardOperator == (Object)(object)botController && (Object)(object)val.GetCallerPhone() == (Object)(object)val3))))
			{
				return true;
			}
			return false;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool AreWeInOrbit(StartOfRound? instanceSOR = null)
		{
			if (instanceSOR == null)
			{
				instanceSOR = StartOfRound.Instance;
			}
			if ((Object)(object)instanceSOR != (Object)null)
			{
				return instanceSOR.inShipPhase;
			}
			return false;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool IsTheShipLanded(StartOfRound? instanceSOR = null)
		{
			if (instanceSOR == null)
			{
				instanceSOR = StartOfRound.Instance;
			}
			if ((Object)(object)instanceSOR != (Object)null && instanceSOR.shipHasLanded)
			{
				return !IsTheShipLeaving(instanceSOR);
			}
			return false;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool IsTheShipLanding(StartOfRound? instanceSOR = null)
		{
			if (instanceSOR == null)
			{
				instanceSOR = StartOfRound.Instance;
			}
			if ((Object)(object)instanceSOR != (Object)null && !instanceSOR.shipHasLanded && !AreWeInOrbit(instanceSOR))
			{
				return !IsTheShipLeaving(instanceSOR);
			}
			return false;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool IsTheShipLeaving(StartOfRound? instanceSOR = null)
		{
			if (instanceSOR == null)
			{
				instanceSOR = StartOfRound.Instance;
			}
			if ((Object)(object)instanceSOR != (Object)null)
			{
				if (!instanceSOR.shipIsLeaving)
				{
					return instanceSOR.shipLeftAutomatically;
				}
				return true;
			}
			return false;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool CanBotsSpawnAtCompanyBuilding()
		{
			if (Plugin.IsModNavmeshInCompanyLoaded)
			{
				return true;
			}
			return false;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool AreWeAtTheCompanyBuilding(bool checkOrbit = true)
		{
			if (StartOfRound.Instance.currentLevel.levelID == 3)
			{
				if (checkOrbit)
				{
					return !AreWeInOrbit();
				}
				return true;
			}
			return false;
		}

		public static bool AreThereItemsOnDesk()
		{
			if (!AreWeAtTheCompanyBuilding())
			{
				return false;
			}
			return GetNumberOfItemsOnDesk() > 0;
		}

		public static int GetNumberOfItemsOnDesk()
		{
			if (!AreWeAtTheCompanyBuilding())
			{
				return 0;
			}
			DepositItemsDesk companyDesk = CompanyDesk;
			if ((Object)(object)companyDesk != (Object)null)
			{
				return ((Component)companyDesk.deskObjectsContainer).GetComponentsInChildren<GrabbableObject>().Length;
			}
			return 0;
		}

		public static int GetValueOfItemsOnDesk()
		{
			if (!AreWeAtTheCompanyBuilding())
			{
				return 0;
			}
			DepositItemsDesk companyDesk = CompanyDesk;
			if ((Object)(object)companyDesk != (Object)null)
			{
				int num = 0;
				GrabbableObject[] componentsInChildren = ((Component)companyDesk.deskObjectsContainer).GetComponentsInChildren<GrabbableObject>();
				GrabbableObject[] array = componentsInChildren;
				foreach (GrabbableObject val in array)
				{
					if (!((Object)(object)val == (Object)null))
					{
						num += val.scrapValue;
					}
				}
				return num;
			}
			return 0;
		}

		public static int GetValueOfAllScrapOnShip(LethalBotAI lethalBotAI, bool shipOnly = false)
		{
			int num = 0;
			for (int i = 0; i < grabbableObjectsInMap.Count; i++)
			{
				GameObject val = grabbableObjectsInMap[i];
				if ((Object)(object)val == (Object)null)
				{
					grabbableObjectsInMap.TrimExcess();
					continue;
				}
				GrabbableObject component = val.GetComponent<GrabbableObject>();
				if (!((Object)(object)component == (Object)null) && !(component is RagdollGrabbableObject) && (!shipOnly || component.isInElevator || component.isInShipRoom) && !lethalBotAI.IsGrabbableObjectBlackListed(component, EnumGrabbableObjectCall.Selling) && (!Plugin.IsModCustomItemBehaviourLibraryLoaded || !LethalBotAI.IsGrabbableObjectInContainerMod(component)) && (!Plugin.IsModLethalMinLoaded || !LethalBotAI.IsGrabbableObjectHeldByPikminMod(component)) && lethalBotAI.IsGrabbableObjectSellable(component, ignoreHeldFlag: true))
				{
					num += component.scrapValue;
				}
			}
			return num;
		}

		public static bool HaveWeFulfilledTheProfitQuota()
		{
			if (Plugin.Config.SellAllScrapOnShip.Value)
			{
				return false;
			}
			TimeOfDay instance = TimeOfDay.Instance;
			if ((Object)(object)instance == (Object)null)
			{
				Plugin.LogWarning("HaveWeFulfilledTheProfitQuota: TimeOfDay instance is null, returning false.");
				return false;
			}
			int num = instance.quotaFulfilled + GetValueOfItemsOnDesk();
			Plugin.LogDebug($"HaveWeFulfilledTheProfitQuota: Quota fulfilled: {num}, Profit quota: {instance.profitQuota}");
			return num >= instance.profitQuota;
		}

		public void UpdateLethalBotsXP(StartOfRound instanceSOR, EndOfGameStats stats, bool localPlayerWasMostProfitable = false)
		{
			HUDManager instance = HUDManager.Instance;
			PlayerControllerB val = null;
			if (!localPlayerWasMostProfitable)
			{
				int num = -1;
				int num2 = 0;
				for (int i = 0; i < stats.allPlayerStats.Length; i++)
				{
					PlayerStats val2 = stats.allPlayerStats[i];
					if (num == -1 || val2.profitable > num2)
					{
						num = i;
						num2 = val2.profitable;
					}
				}
				if (num != -1 && num2 > 50)
				{
					val = instanceSOR.allPlayerScripts[num];
				}
			}
			foreach (EndOfGameBotStats allBotEndOfGameStat in AllBotEndOfGameStats)
			{
				if (allBotEndOfGameStat == null || allBotEndOfGameStat.Identity == null)
				{
					continue;
				}
				PlayerControllerB botController = allBotEndOfGameStat.BotController;
				int valueOrDefault = allBotEndOfGameStat.Identity.XP.GetValueOrDefault();
				int lethalBotLevel = GetLethalBotLevel(!allBotEndOfGameStat.IsAlive, (Object)(object)botController == (Object)(object)val, instanceSOR.allPlayersDead);
				int num3 = Mathf.Max(valueOrDefault + lethalBotLevel, 0);
				int num4 = 0;
				for (int j = 0; j < instance.playerLevels.Length; j++)
				{
					PlayerLevel val3 = instance.playerLevels[j];
					if (num3 >= val3.XPMin && num3 < val3.XPMax)
					{
						num4 = j;
						break;
					}
					if (j == instance.playerLevels.Length - 1)
					{
						num4 = j;
					}
				}
				allBotEndOfGameStat.Identity.XP = num3;
				allBotEndOfGameStat.Identity.Level = num4;
				Plugin.LogDebug($"Updated XP for bot {botController.playerUsername} to {allBotEndOfGameStat.Identity.XP}");
				instance.SyncPlayerLevelServerRpc((int)botController.playerClientId, num4, true);
				UpdateLethalBotsXPServerRpc((int)botController.playerClientId, num3, num4);
			}
			AllBotEndOfGameStats.Clear();
		}

		private static int GetLethalBotLevel(bool isDead, bool mostProfitable, bool allPlayersDead)
		{
			int num = 0;
			num = ((!isDead) ? (num + 10) : (num - 3));
			if (mostProfitable)
			{
				num += 15;
			}
			if (allPlayersDead)
			{
				num -= 5;
			}
			if (num > 0)
			{
				Plugin.LogInfo($"XP gain before scaling to scrap returned: {num}");
				Plugin.LogInfo($"{(float)RoundManager.Instance.scrapCollectedInLevel / RoundManager.Instance.totalScrapValueInLevel}");
				float num2 = (float)RoundManager.Instance.scrapCollectedInLevel / RoundManager.Instance.totalScrapValueInLevel;
				Plugin.LogInfo($"{num2}");
				num = (int)((float)num * num2);
			}
			return num;
		}

		[ServerRpc(RequireOwnership = false)]
		public void UpdateLethalBotsXPServerRpc(int playerId, int newIdentityXP, int newIdentityLevel)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: 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_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val = default(ServerRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(2251955273u, val, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val2, playerId);
					BytePacker.WriteValueBitPacked(val2, newIdentityXP);
					BytePacker.WriteValueBitPacked(val2, newIdentityLevel);
					((NetworkBehaviour)this).__endSendServerRpc(ref val2, 2251955273u, val, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					UpdateLethalBotsXPClientRpc(playerId, newIdentityXP, newIdentityLevel);
				}
			}
		}

		[ClientRpc]
		private void UpdateLethalBotsXPClientRpc(int playerId, int newIdentityXP, int newIdentityLevel)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: 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_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val = default(ClientRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(4055705094u, val, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val2, playerId);
				BytePacker.WriteValueBitPacked(val2, newIdentityXP);
				BytePacker.WriteValueBitPacked(val2, newIdentityLevel);
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 4055705094u, val, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage != 1 || (!networkManager.IsClient && !networkManager.IsHost))
			{
				return;
			}
			base.__rpc_exec_stage = (__RpcExecStage)0;
			Plugin.LogDebug($"UpdateLethalBotsXPClientRpc: {playerId}, {newIdentityXP}, {newIdentityLevel}");
			PlayerControllerB val3 = ((playerId < StartOfRound.Instance.allPlayerScripts.Length) ? StartOfRound.Instance.allPlayerScripts[playerId] : null);
			if ((Object)(object)val3 != (Object)null)
			{
				LethalBotAI lethalBotAI = GetLethalBotAI(val3);
				if ((Object)(object)lethalBotAI != (Object)null)
				{
					LethalBotIdentity lethalBotIdentity = lethalBotAI.LethalBotIdentity;
					lethalBotIdentity.XP = newIdentityXP;
					lethalBotIdentity.Level = newIdentityLevel;
					Plugin.LogDebug($"Updated XP for bot {val3.playerUsername} to {lethalBotIdentity.XP}");
				}
			}
			else
			{
				Plugin.LogWarning($"Player Controller with ID {playerId} not found!");
			}
		}

		public void SpawnLethalBotsAtShip(bool markBotsAsLoaded = false)
		{
			if ((!AreWeAtTheCompanyBuilding(checkOrbit: false) || CanBotsSpawnAtCompanyBuilding()) && (((NetworkBehaviour)this).IsServer || ((NetworkBehaviour)this).IsHost))
			{
				if (spawnLethalBotsAtShipCoroutine != null)
				{
					((MonoBehaviour)this).StopCoroutine(spawnLethalBotsAtShipCoroutine);
				}
				spawnLethalBotsAtShipCoroutine = ((MonoBehaviour)this).StartCoroutine(SpawnLethalBotsCoroutine(markBotsAsLoaded));
			}
		}

		[IteratorStateMachine(typeof(<SpawnLethalBotsCoroutine>d__158))]
		private IEnumerator SpawnLethalBotsCoroutine(bool markBotsAsLoaded)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <SpawnLethalBotsCoroutine>d__158(0)
			{
				<>4__this = this,
				markBotsAsLoaded = markBotsAsLoaded
			};
		}

		[ServerRpc(RequireOwnership = false)]
		public void SendNewPlayerCountServerRpc(int numConnectedPlayers, int numLivingPlayers, int numRealPlayers, ServerRpcParams rpcParams = default(ServerRpcParams))
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: 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_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(3828485747u, rpcParams, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val, numConnectedPlayers);
				BytePacker.WriteValueBitPacked(val, numLivingPlayers);
				BytePacker.WriteValueBitPacked(val, numRealPlayers);
				((NetworkBehaviour)this).__endSendServerRpc(ref val, 3828485747u, rpcParams, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				if (rpcParams.Receive.SenderClientId != 0L)
				{
					Plugin.LogWarning($"Unauthorized client {rpcParams.Receive.SenderClientId} attempted to update player counts!");
					return;
				}
				StartOfRound instance = StartOfRound.Instance;
				int connectedPlayersAmount = instance.connectedPlayersAmount;
				int livingPlayers = instance.livingPlayers;
				instance.connectedPlayersAmount = numConnectedPlayers;
				instance.livingPlayers = numLivingPlayers;
				AllRealPlayersCount = numRealPlayers;
				Plugin.LogInfo($"[Server] Old Num of Connected Players {connectedPlayersAmount} -> {instance.connectedPlayersAmount}");
				Plugin.LogInfo($"[Server] Old Num of Living Players {livingPlayers} -> {instance.livingPlayers}");
				Plugin.LogInfo($"[Server] Real Players Count: {AllRealPlayersCount}");
				sendPlayerCountUpdate.Value = false;
				SendNewPlayerCountClientRpc(numConnectedPlayers, numLivingPlayers, numRealPlayers);
			}
		}

		[ClientRpc]
		private void SendNewPlayerCountClientRpc(int numConnectedPlayers, int numLivingPlayers, int numRealPlayers)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: 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_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val = default(ClientRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(765310706u, val, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val2, numConnectedPlayers);
				BytePacker.WriteValueBitPacked(val2, numLivingPlayers);
				BytePacker.WriteValueBitPacked(val2, numRealPlayers);
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 765310706u, val, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				if (!((NetworkBehaviour)this).IsServer && !((NetworkBehaviour)this).IsHost)
				{
					Plugin.LogInfo("[Client] Received updated player counts!");
					StartOfRound instance = StartOfRound.Instance;
					int connectedPlayersAmount = instance.connectedPlayersAmount;
					int livingPlayers = instance.livingPlayers;
					instance.connectedPlayersAmount = numConnectedPlayers;
					instance.livingPlayers = numLivingPlayers;
					AllRealPlayersCount = numRealPlayers;
					Plugin.LogInfo($"[Client] Old Num of Connected Players {connectedPlayersAmount} -> {instance.connectedPlayersAmount}");
					Plugin.LogInfo($"[Client] Old Num of Living Players {livingPlayers} -> {instance.livingPlayers}");
					Plugin.LogInfo($"[Client] Real Players Count: {AllRealPlayersCount}");
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void RequestPlayerCountServerRpc(ulong clientId)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val = default(ServerRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(3244699581u, val, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val2, clientId);
					((NetworkBehaviour)this).__endSendServerRpc(ref val2, 3244699581u, val, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					Plugin.LogInfo($"Client {clientId} ask server/host {((NetworkBehaviour)this).NetworkManager.LocalClientId} to update number of real players.");
					AllRealPlayersCount = GameNetworkManager.Instance.connectedPlayers;
					Plugin.LogInfo($"[Server] Real Players Count: {AllRealPlayersCount}");
					RequestPlayerCountClientRpc(AllRealPlayersCount);
				}
			}
		}

		[ClientRpc]
		private void RequestPlayerCountClientRpc(int numRealPlayers)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val = default(ClientRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(2483945957u, val, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val2, numRealPlayers);
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 2483945957u, val, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				if (!((NetworkBehaviour)this).IsServer && !((NetworkBehaviour)this).IsHost)
				{
					Plugin.LogInfo("[Client] Received updated player counts!");
					AllRealPlayersCount = numRealPlayers;
					Plugin.LogInfo($"[Client] Real Players Count: {AllRealPlayersCount}");
				}
			}
		}

		public void TeleportOutLethalBots(ShipTeleporter teleporter, Random shipTeleporterSeed)
		{
			if (BeamOutLethalBotsCoroutine != null)
			{
				((MonoBehaviour)this).StopCoroutine(BeamOutLethalBotsCoroutine);
			}
			BeamOutLethalBotsCoroutine = ((MonoBehaviour)this).StartCoroutine(BeamOutLethalBots(teleporter, shipTeleporterSeed));
		}

		[IteratorStateMachine(typeof(<BeamOutLethalBots>d__164))]
		private IEnumerator BeamOutLethalBots(ShipTeleporter teleporter, Random shipTeleporterSeed)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <BeamOutLethalBots>d__164(0)
			{
				<>4__this = this,
				teleporter = teleporter
			};
		}

		[ServerRpc(RequireOwnership = false)]
		public void SetHangarShipDoorStateServerRpc(bool isClosed)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val = default(ServerRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(2917048395u, val, (RpcDelivery)0);
					((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref isClosed, default(ForPrimitives));
					((NetworkBehaviour)this).__endSendServerRpc(ref val2, 2917048395u, val, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					SetHangarShipDoorStateClientRpc(isClosed);
				}
			}
		}

		[ClientRpc]
		public void SetHangarShipDoorStateClientRpc(bool isClosed)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val = default(ClientRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(611045299u, val, (RpcDelivery)0);
				((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref isClosed, default(ForPrimitives));
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 611045299u, val, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				HangarShipDoor shipDoor = ShipDoor;
				if ((Object)(object)shipDoor != (Object)null && shipDoor.buttonsEnabled)
				{
					shipDoor.shipDoorsAnimator.SetBool("Closed", isClosed);
					StartOfRound.Instance.SetShipDoorsClosed(isClosed);
					shipDoor.PlayDoorAnimation(isClosed);
				}
			}
		}

		[IteratorStateMachine(typeof(<trappedPlayerCheck>d__167))]
		private IEnumerator trappedPlayerCheck()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <trappedPlayerCheck>d__167(0)
			{
				<>4__this = this
			};
		}

		private void StartTrappedPlayerCoroutine()
		{
			if (trappedPlayerCheckCoroutine == null)
			{
				trappedPlayerCheckCoroutine = ((MonoBehaviour)this).StartCoroutine(trappedPlayerCheck());
			}
		}

		private void StopTrappedPlayerCoroutine()
		{
			if (trappedPlayerCheckCoroutine != null)
			{
				((MonoBehaviour)this).StopCoroutine(trappedPlayerCheckCoroutine);
				trappedPlayerCheckCoroutine = null;
			}
		}

		public bool CanPlayerPathToExit(PlayerControllerB player)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Expected O, but got Unknown
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			Vector3 navMeshPosition = RoundManager.Instance.GetNavMeshPosition(((Component)player).transform.position, RoundManager.Instance.navHit, 2.7f, -1);
			LethalBotAI lethalBotAI = GetLethalBotAI(player);
			bool flag = (((Object)(object)lethalBotAI != (Object)null) ? ((EnemyAI)lethalBotAI).isOutside : (!player.isInsideFactory));
			int areaMask = (((Object)(object)lethalBotAI != (Object)null) ? ((EnemyAI)lethalBotAI).agent.areaMask : (-1));
			NavMeshPath path = new NavMeshPath();
			EntranceTeleport[] entrancesTeleportArray = LethalBotAI.EntrancesTeleportArray;
			foreach (EntranceTeleport val in entrancesTeleportArray)
			{
				if (((flag && val.isEntranceToBuilding) || (!flag && !val.isEntranceToBuilding)) && val.FindExitPoint())
				{
					Vector3 navMeshPosition2 = RoundManager.Instance.GetNavMeshPosition(val.entrancePoint.position, RoundManager.Instance.navHit, 2.7f, -1);
					if (IsValidPathToEntrance(navMeshPosition, navMeshPosition2, areaMask, ref path, val))
					{
						return true;
					}
				}
			}
			return false;
		}

		public static bool IsValidPathToEntrance(Vector3 startPosition, Vector3 entrancePosition, int areaMask, ref NavMeshPath path, EntranceTeleport targetEntrance)
		{
			//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_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: 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_005d: Unknown result type (might be due to invalid IL or missing references)
			if (!LethalBotAI.IsValidPathToTarget(startPosition, entrancePosition, areaMask, ref path, calculatePathDistance: false, out var pathDistance))
			{
				if (AIState.IsFrontEntrance(targetEntrance) && !targetEntrance.isEntranceToBuilding && (Object)(object)LethalBotAI.ElevatorScript != (Object)null)
				{
					if (LethalBotAI.IsValidPathToTarget(startPosition, LethalBotAI.ElevatorScript.elevatorBottomPoint.position, areaMask, ref path, calculatePathDistance: false, out pathDistance))
					{
						return true;
					}
					Bounds bounds = LethalBotAI.ElevatorScript.elevatorBounds.bounds;
					return ((Bounds)(ref bounds)).Contains(startPosition);
				}
				return false;
			}
			return true;
		}

		public static bool IsShipCompromised(LethalBotAI? lethalBotAI = null, bool bypassCooldown = false)
		{
			if (!bypassCooldown && Time.timeSinceLevelLoad - nextCheckForShipSafety < 0.9f)
			{
				return _isShipCompromised;
			}
			nextCheckForShipSafety = Time.timeSinceLevelLoad;
			RoundManager instance = RoundManager.Instance;
			foreach (EnemyAI spawnedEnemy in instance.SpawnedEnemies)
			{
				if (GetFearRangeForEnemy(new LethalBotFearQuery((EnemyAI?)(object)lethalBotAI, spawnedEnemy, EnumFearQueryType.BotPanic)).HasValue)
				{
					int layermaskForEnemySizeLimit = instance.GetLayermaskForEnemySizeLimit(spawnedEnemy.enemyType, false, -1);
					if (layermaskForEnemySizeLimit != 1 && !spawnedEnemy.isEnemyDead && spawnedEnemy.isInsidePlayerShip)
					{
						_isShipCompromised = true;
						return true;
					}
				}
			}
			_isShipCompromised = false;
			return false;
		}

		public bool AreAllHumanPlayersDead(bool bypassCooldown = false)
		{
			if (!bypassCooldown && Time.timeSinceLevelLoad - nextCheckForAliveHumanPlayers < 0.9f)
			{
				return _areAllHumanPlayersDead;
			}
			nextCheckForAliveHumanPlayers = Time.timeSinceLevelLoad;
			PlayerControllerB[] allPlayerScripts = StartOfRound.Instance.allPlayerScripts;
			foreach (PlayerControllerB val in allPlayerScripts)
			{
				if (val.isPlayerControlled && !val.isPlayerDead && !IsPlayerLethalBot(val) && (!Plugin.IsModLethalInternsLoaded || !IsPlayerIntern(val)))
				{
					_areAllHumanPlayersDead = false;
					return false;
				}
			}
			_areAllHumanPlayersDead = true;
			return true;
		}

		public bool AreAllPlayersOnTheShip(bool bypassCooldown = false)
		{
			if (!bypassCooldown && Time.timeSinceLevelLoad - nextCheckForAllPlayersOnShip < 0.9f)
			{
				return _areAllPlayersOnTheShip;
			}
			nextCheckForAllPlayersOnShip = Time.timeSinceLevelLoad;
			PlayerControllerB[] allPlayerScripts = StartOfRound.Instance.allPlayerScripts;
			foreach (PlayerControllerB val in allPlayerScripts)
			{
				if (val.isPlayerControlled && !val.isPlayerDead && (!Plugin.IsModLethalInternsLoaded || !IsPlayerIntern(val)) && !val.isInElevator && !val.isInHangarShipRoom)
				{
					_areAllPlayersOnTheShip = false;
					return false;
				}
			}
			_areAllPlayersOnTheShip = true;
			return true;
		}

		public LethalBotAI? GetLethalBotAI(int playerClientId)
		{
			if (AllLethalBotAIs == null || AllLethalBotAIs.Length == 0)
			{
				return null;
			}
			return AllLethalBotAIs[playerClientId];
		}

		public LethalBotAI? GetLethalBotAI(PlayerControllerB player)
		{
			if (AllLethalBotAIs == null || AllLethalBotAIs.Length == 0 || (Object)(object)player == (Object)null)
			{
				return null;
			}
			return AllLethalBotAIs[player.playerClientId];
		}

		public LethalBotAI? GetLethalBotAIIfLocalIsOwner(int index)
		{
			LethalBotAI lethalBotAI = GetLethalBotAI(index);
			if ((Object)(object)lethalBotAI != (Object)null && ((NetworkBehaviour)lethalBotAI).OwnerClientId == GameNetworkManager.Instance.localPlayerController.actualClientId)
			{
				return lethalBotAI;
			}
			return null;
		}

		public LethalBotAI? GetLethalBotAIIfLocalIsOwner(PlayerControllerB player)
		{
			LethalBotAI lethalBotAI = GetLethalBotAI(player);
			if ((Object)(object)lethalBotAI != (Object)null && ((NetworkBehaviour)lethalBotAI).OwnerClientId == GameNetworkManager.Instance.localPlayerController.actualClientId)
			{
				return lethalBotAI;
			}
			return null;
		}

		public LethalBotAI? GetLethalBotAiOwnerOfObject(GrabbableObject grabbableObject)
		{
			LethalBotAI[] allLethalBotAIs = AllLethalBotAIs;
			foreach (LethalBotAI lethalBotAI in allLethalBotAIs)
			{
				if (!((Object)(object)lethalBotAI == (Object)null) && ((NetworkBehaviour)lethalBotAI).IsSpawned && !((EnemyAI)lethalBotAI).isEnemyDead && lethalBotAI.NpcController != null && !lethalBotAI.NpcController.Npc.isPlayerDead && lethalBotAI.NpcController.Npc.isPlayerControlled && lethalBotAI.HasGrabbableObjectInInventory(grabbableObject, out var _))
				{
					return lethalBotAI;
				}
			}
			return null;
		}

		public bool IsPlayerLethalBot(PlayerControllerB? player)
		{
			if ((Object)(object)player == (Object)null)
			{
				return false;
			}
			LethalBotAI lethalBotAI = GetLethalBotAI(player);
			return (Object)(object)lethalBotAI != (Object)null;
		}

		public bool IsPlayerLethalBot(int id)
		{
			LethalBotAI lethalBotAI = GetLethalBotAI(id);
			return (Object)(object)lethalBotAI != (Object)null;
		}

		internal static bool IsPlayerIntern(PlayerControllerB player)
		{
			if ((Object)(object)player == (Object)null)
			{
				return false;
			}
			return InternManager.Instance.IsPlayerIntern(player);
		}

		internal bool IsPlayerIntern(int id)
		{
			InternAI internAI = InternManager.Instance.GetInternAI(id);
			return (Object)(object)internAI != (Object)null;
		}

		public bool IsAILethalBotAi(EnemyAI ai)
		{
			LethalBotAI[] allLethalBotAIs = AllLethalBotAIs;
			foreach (LethalBotAI lethalBotAI in allLethalBotAIs)
			{
				if ((Object)(object)lethalBotAI == (Object)(object)ai)
				{
					return true;
				}
			}
			return false;
		}

		public bool IsPlayerLocalOrLethalBotOwnerLocal(PlayerControllerB player)
		{
			if (IsPlayerLocal(player))
			{
				return true;
			}
			LethalBotAI lethalBotAI = GetLethalBotAI(player);
			if ((Object)(object)lethalBotAI == (Object)null)
			{
				return false;
			}
			return ((NetworkBehaviour)lethalBotAI).OwnerClientId == GameNetworkManager.Instance.localPlayerController.actualClientId;
		}

		public bool IsPlayerLocalOrLethalBot(PlayerControllerB player)
		{
			if (IsPlayerLocal(player))
			{
				return true;
			}
			LethalBotAI lethalBotAI = GetLethalBotAI(player);
			return (Object)(object)lethalBotAI != (Object)null;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool IsPlayerLocal(PlayerControllerB player)
		{
			if ((Object)(object)player != (Object)null)
			{
				return (Object)(object)player == (Object)(object)GameNetworkManager.Instance.localPlayerController;
			}
			return false;
		}

		public bool IsColliderFromLocalOrLethalBotOwnerLocal(Collider collider)
		{
			PlayerControllerB component = ((Component)collider).gameObject.GetComponent<PlayerControllerB>();
			return IsPlayerLocalOrLethalBotOwnerLocal(component);
		}

		public bool IsPlayerLethalBotOwnerLocal(PlayerControllerB player)
		{
			if ((Object)(object)player == (Object)null)
			{
				return false;
			}
			LethalBotAI lethalBotAI = GetLethalBotAI(player);
			if ((Object)(object)lethalBotAI == (Object)null)
			{
				return false;
			}
			return ((NetworkBehaviour)lethalBotAI).OwnerClientId == GameNetworkManager.Instance.localPlayerController.actualClientId;
		}

		public bool IsIdPlayerLethalBotOwnerLocal(int idPlayer)
		{
			LethalBotAI lethalBotAI = GetLethalBotAI(idPlayer);
			if ((Object)(object)lethalBotAI == (Object)null)
			{
				return false;
			}
			return ((NetworkBehaviour)lethalBotAI).OwnerClientId == GameNetworkManager.Instance.localPlayerController.actualClientId;
		}

		public bool IsPlayerLethalBotControlledAndOwner(PlayerControllerB player)
		{
			if (IsPlayerLethalBotOwnerLocal(player))
			{
				return player.isPlayerControlled;
			}
			return false;
		}

		public bool IsAnLethalBotAiOwnerOfObject(GrabbableObject grabbableObject)
		{
			LethalBotAI lethalBotAiOwnerOfObject = GetLethalBotAiOwnerOfObject(grabbableObject);
			if ((Object)(object)lethalBotAiOwnerOfObject == (Object)null)
			{
				return false;
			}
			return true;
		}

		public LethalBotAI[] GetLethalBotsAIOwnedByLocal()
		{
			StartOfRound instance = StartOfRound.Instance;
			List<LethalBotAI> list = new List<LethalBotAI>();
			for (int i = 0; i < instance.allPlayerScripts.Length; i++)
			{
				LethalBotAI lethalBotAIIfLocalIsOwner = GetLethalBotAIIfLocalIsOwner(instance.allPlayerScripts[i]);
				if ((Object)(object)lethalBotAIIfLocalIsOwner != (Object)null)
				{
					list.Add(lethalBotAIIfLocalIsOwner);
				}
			}
			return list.ToArray();
		}

		public LethalBotAI[] GetLethalBotAIs()
		{
			StartOfRound instance = StartOfRound.Instance;
			List<LethalBotAI> list = new List<LethalBotAI>();
			for (int i = 0; i < instance.allPlayerScripts.Length; i++)
			{
				LethalBotAI lethalBotAI = GetLethalBotAI(instance.allPlayerScripts[i]);
				if ((Object)(object)lethalBotAI != (Object)null)
				{
					list.Add(lethalBotAI);
				}
			}
			return list.ToArray();
		}

		public void SetLethalBotsInElevatorLateUpdate(float deltaTime)
		{
			timerSetLethalBotInElevator += deltaTime;
			if ((double)timerSetLethalBotInElevator < 0.5)
			{
				return;
			}
			timerSetLethalBotInElevator = 0f;
			LethalBotAI[] allLethalBotAIs = AllLethalBotAIs;
			foreach (LethalBotAI lethalBotAI in allLethalBotAIs)
			{
				if (!((Object)(object)lethalBotAI == (Object)null))
				{
					lethalBotAI.SetLethalBotInElevator();
				}
			}
		}

		public void UpdateOwnershipOfBotServer(float deltaTime)
		{
			timerUpdateOwnershipOfBot += deltaTime;
			if ((double)timerUpdateOwnershipOfBot < 0.5 || !((NetworkBehaviour)this).IsServer)
			{
				return;
			}
			timerUpdateOwnershipOfBot = 0f;
			LethalBotAI[] allLethalBotAIs = AllLethalBotAIs;
			foreach (LethalBotAI lethalBotAI in allLethalBotAIs)
			{
				if (!((Object)(object)lethalBotAI == (Object)null) && lethalBotAI.NpcController != null)
				{
					lethalBotAI.UpdateOwnershipOfBotServer();
				}
			}
		}

		public bool IsLocalPlayerNextToChillLethalBots()
		{
			LethalBotAI[] allLethalBotAIs = AllLethalBotAIs;
			foreach (LethalBotAI lethalBotAI in allLethalBotAIs)
			{
				if (!((Object)(object)lethalBotAI == (Object)null) && ((NetworkBehaviour)lethalBotAI).IsSpawned && !((EnemyAI)lethalBotAI).isEnemyDead && lethalBotAI.NpcController != null && !lethalBotAI.NpcController.Npc.isPlayerDead && lethalBotAI.NpcController.Npc.isPlayerControlled && ((NetworkBehaviour)lethalBotAI).OwnerClientId == GameNetworkManager.Instance.localPlayerController.actualClientId && lethalBotAI.State != null && lethalBotAI.State.GetAIState() == EnumAIStates.ChillWithPlayer)
				{
					return true;
				}
			}
			return false;
		}

		public int GetDamageFromSlimeIfLethalBot(PlayerControllerB player)
		{
			if (IsPlayerLethalBot(player))
			{
				return 5;
			}
			return 35;
		}

		public int MaxHealthPercent(int percentage, int maxHealth)
		{
			int num = (int)((double)percentage / 100.0 * (double)maxHealth);
			if (num >= 1)
			{
				return num;
			}
			return 1;
		}

		private void EndOfRoundForLethalBots(bool preRevive = false)
		{
			DictEnemyAINoiseListeners.Clear();
			ListEnemyAINonNoiseListeners.Clear();
			if (((NetworkBehaviour)this).IsServer || ((NetworkBehaviour)this).IsHost)
			{
				MissionControlPlayer = null;
				LootTransferPlayers.Clear();
				GroupManager.Instance.ResetAndRemoveAllGroups();
			}
			SetLastReportedTimeOfDay((DayMode)0);
			AIState.ResetEntranceSafetyCache();
			if (preRevive)
			{
				CountAliveAndDisableLethalBots(preRevive);
			}
			else
			{
				CountAliveAndDisableLethalBots();
			}
		}

		private void CountAliveAndDisableLethalBots()
		{
			//IL_036f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0375: Unknown result type (might be due to invalid IL or missing references)
			//IL_018d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_0207: Unknown result type (might be due to invalid IL or missing references)
			StartOfRound instance = StartOfRound.Instance;
			if (AreWeAtTheCompanyBuilding(checkOrbit: false) && !CanBotsSpawnAtCompanyBuilding())
			{
				return;
			}
			if (Plugin.Config.AllowBotsInOrbit.Value)
			{
				AllBotPlayerIndexs.Clear();
				LethalBotAI[] lethalBotAIs = GetLethalBotAIs();
				foreach (LethalBotAI lethalBotAI in lethalBotAIs)
				{
					PlayerControllerB val = lethalBotAI.NpcController?.Npc;
					if ((Object)(object)val != (Object)null)
					{
						if (lethalBotAI.LethalBotIdentity.DiedLastRound)
						{
							val.hinderedMultiplier = 1f;
							val.isMovementHindered = 0;
							val.sourcesCausingSinking = 0;
							val.reverbPreset = StartOfRound.Instance.shipReverb;
							val.SpawnPlayerAnimation();
						}
						int num = (int)val.playerClientId;
						SoundManager.Instance.playerVoicePitchTargets[num] = lethalBotAI.LethalBotIdentity.Voice.VoicePitch;
						SoundManager.Instance.SetPlayerPitch(lethalBotAI.LethalBotIdentity.Voice.VoicePitch, num);
					}
				}
				return;
			}
			foreach (int allBotPlayerIndex in AllBotPlayerIndexs)
			{
				if (allBotPlayerIndex < 0 || allBotPlayerIndex >= instance.allPlayerScripts.Length)
				{
					continue;
				}
				PlayerControllerB val2 = instance.allPlayerScripts[allBotPlayerIndex];
				if (!((Object)(object)val2 == (Object)null) && val2.isPlayerControlled)
				{
					if (((NetworkBehaviour)this).IsServer)
					{
						((UnityEvent<PlayerControllerB, int>)(object)StartOfRound.Instance.LocalPlayerDieEvent).Invoke(val2, 200);
					}
					if (Plugin.IsModModelReplacementAPILoaded)
					{
						RemovePlayerModelReplacement(val2);
					}
					val2.isPlayerControlled = false;
					val2.TeleportPlayer(instance.notSpawnedPosition.position, false, 0f, false, true);
					val2.localVisor.position = instance.notSpawnedPosition.position;
					val2.DisablePlayerModel(instance.allPlayerObjects[allBotPlayerIndex] ?? ((Component)val2).gameObject, true, true);
					Animator playerBodyAnimator = val2.playerBodyAnimator;
					if ((Object)(object)playerBodyAnimator != (Object)null)
					{
						playerBodyAnimator.Rebind(true);
						playerBodyAnimator.Update(0f);
					}
					((Component)val2).transform.position = instance.notSpawnedPosition.position;
					((Collider)val2.thisController).enabled = false;
					if (!NetworkManager.Singleton.ShutdownInProgress && ((NetworkBehaviour)this).IsServer)
					{
						((Component)val2).gameObject.GetComponent<NetworkObject>().RemoveOwnership();
					}
					QuickMenuManager val3 = Object.FindObjectOfType<QuickMenuManager>();
					if ((Object)(object)val3 != (Object)null)
					{
						val3.RemoveUserFromPlayerList(allBotPlayerIndex);
					}
					ulong actualClientId = val2.actualClientId;
					StartOfRound.Instance.ClientPlayerList.Remove(actualClientId);
					if (instance.fullyLoadedPlayers.Contains(actualClientId))
					{
						instance.fullyLoadedPlayers.Remove(actualClientId);
					}
					if (RoundManager.Instance.playersFinishedGeneratingFloor.Contains(actualClientId))
					{
						RoundManager.Instance.playersFinishedGeneratingFloor.Remove(actualClientId);
					}
					if (GameNetworkManager.Instance.disableSteam)
					{
						string text = (val2.playerUsername = $"Player #{allBotPlayerIndex}");
						((TMP_Text)val2.usernameBillboardText).text = text;
						StartOfRound.Instance.mapScreen.radarTargets[allBotPlayerIndex].name = text;
					}
				}
			}
			AllBotPlayerIndexs.Clear();
			if (((NetworkBehaviour)this).IsServer || ((NetworkBehaviour)this).IsHost)
			{
				int numConnectedPlayers = GameNetworkManager.Instance.connectedPlayers - 1;
				int connectedPlayers = GameNetworkManager.Instance.connectedPlayers;
				SendNewPlayerCountServerRpc(numConnectedPlayers, connectedPlayers, GameNetworkManager.Instance.connectedPlayers);
			}
		}

		private void CountAliveAndDisableLethalBots(bool _)
		{
			//IL_011d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_0131: Unknown result type (might be due to invalid IL or missing references)
			//IL_0141: Unknown result type (might be due to invalid IL or missing references)
			//IL_0158: Unknown result type (might be due to invalid IL or missing references)
			//IL_015a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0165: Unknown result type (might be due to invalid IL or missing references)
			//IL_0172: Unknown result type (might be due to invalid IL or missing references)
			//IL_017a: Unknown result type (might be due to invalid IL or missing references)
			//IL_017c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0187: Unknown result type (might be due to invalid IL or missing references)
			//IL_0194: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0329: Unknown result type (might be due to invalid IL or missing references)
			//IL_032f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0333: Unknown result type (might be due to invalid IL or missing references)
			//IL_0339: Unknown result type (might be due to invalid IL or missing references)
			//IL_033d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0343: Unknown result type (might be due to invalid IL or missing references)
			//IL_0347: Unknown result type (might be due to invalid IL or missing references)
			//IL_034d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0351: Unknown result type (might be due to invalid IL or missing references)
			//IL_0357: Unknown result type (might be due to invalid IL or missing references)
			//IL_0299: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02da: Unknown result type (might be due to invalid IL or missing references)
			//IL_02de: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0203: Unknown result type (might be due to invalid IL or missing references)
			//IL_0216: Unknown result type (might be due to invalid IL or missing references)
			//IL_0227: Unknown result type (might be due to invalid IL or missing references)
			//IL_022c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0230: Unknown result type (might be due to invalid IL or missing references)
			//IL_0235: Unknown result type (might be due to invalid IL or missing references)
			//IL_0237: Unknown result type (might be due to invalid IL or missing references)
			//IL_023c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0246: Unknown result type (might be due to invalid IL or missing references)
			//IL_024b: Unknown result type (might be due to invalid IL or missing references)
			//IL_024d: Unknown result type (might be due to invalid IL or missing references)
			if (AreWeAtTheCompanyBuilding(checkOrbit: false) && !CanBotsSpawnAtCompanyBuilding())
			{
				return;
			}
			AllBotPlayerIndexs.Clear();
			AllBotEndOfGameStats.Clear();
			LethalBotAI[] allLethalBotAIs = AllLethalBotAIs;
			foreach (LethalBotAI lethalBotAI in allLethalBotAIs)
			{
				if ((Object)(object)lethalBotAI == (Object)null || lethalBotAI.NpcController == null)
				{
					continue;
				}
				PlayerControllerB npc = lethalBotAI.NpcController.Npc;
				try
				{
					if (npc.isPlayerControlled && !npc.isPlayerDead)
					{
						if (npc.inTerminalMenu)
						{
							lethalBotAI.LeaveTerminal();
						}
						if (!npc.isInElevator && !npc.isInHangarShipRoom)
						{
							Plugin.LogDebug($"Killing player obj #{npc.playerClientId}, they were not in the ship when it left.");
							npc.KillPlayer(Vector3.zero, false, (CauseOfDeath)10, 0, default(Vector3), false);
							if (((NetworkBehaviour)this).IsOwner)
							{
								HUDManager.Instance.AddTextToChatOnServer(npc.playerUsername + " was left behind.", -1);
							}
						}
						else if (!npc.isInHangarShipRoom)
						{
							npc.isInElevator = true;
							npc.isInHangarShipRoom = true;
							((EnemyAI)lethalBotAI).isInsidePlayerShip = true;
							Vector3 playerSpawnPosition_ReversePatch = StartOfRoundPatch.GetPlayerSpawnPosition_ReversePatch(StartOfRound.Instance, (int)npc.playerClientId, simpleTeleport: false);
							((Collider)npc.thisController).enabled = false;
							npc.TeleportPlayer(playerSpawnPosition_ReversePatch, false, 0f, false, true);
							lethalBotAI.TeleportLethalBot(playerSpawnPosition_ReversePatch, false);
							((EnemyAI)lethalBotAI).serverPosition = playerSpawnPosition_ReversePatch;
							((Component)lethalBotAI).transform.position = playerSpawnPosition_ReversePatch;
							((Component)lethalBotAI).transform.localPosition = playerSpawnPosition_ReversePatch;
							npc.serverPlayerPosition = playerSpawnPosition_ReversePatch;
							((Component)npc).transform.localPosition = playerSpawnPosition_ReversePatch;
							((Component)npc).transform.position = playerSpawnPosition_ReversePatch;
							((Collider)npc.thisController).enabled = true;
							GrabbableObject[] itemSlots = npc.ItemSlots;
							foreach (GrabbableObject val in itemSlots)
							{
								Transform val2 = val?.parentObject;
								if ((Object)(object)val != (Object)null && (Object)(object)val2 != (Object)null)
								{
									((Component)val).transform.rotation = val2.rotation;
									((Component)val).transform.Rotate(val.itemProperties.rotationOffset);
									((Component)val).transform.position = val2.position;
									Vector3 positionOffset = val.itemProperties.positionOffset;
									positionOffset = val2.rotation * positionOffset;
									Transform transform = ((Component)val).transform;
									transform.position += positionOffset;
								}
							}
							GrabbableObject itemOnlySlot = npc.ItemOnlySlot;
							if ((Object)(object)itemOnlySlot != (Object)null)
							{
								Transform parentObject = itemOnlySlot.parentObject;
								if ((Object)(object)parentObject != (Object)null)
								{
									((Component)itemOnlySlot).transform.rotation = parentObject.rotation;
									((Component)itemOnlySlot).transform.Rotate(itemOnlySlot.itemProperties.rotationOffset);
									((Component)itemOnlySlot).transform.position = parentObject.position;
									Vector3 positionOffset2 = itemOnlySlot.itemProperties.positionOffset;
									positionOffset2 = parentObject.rotation * positionOffset2;
									Transform transform2 = ((Component)itemOnlySlot).transform;
									transform2.position += positionOffset2;
								}
							}
						}
						if (!Plugin.Config.AllowBotsInOrbit.Value)
						{
							lethalBotAI.NpcController.StopPreformingEmote(forceStop: true);
							npc.DropAllHeldItems(true, false, false, false, default(Vector3), default(Vector3), default(Vector3), default(Vector3), default(Vector3));
						}
					}
				}
				catch (Exception arg)
				{
					Plugin.LogError($"An error occured during round cleanup! Error: {arg}");
				}
				if (Plugin.Config.AllowBotsInOrbit.Value)
				{
					lethalBotAI.LethalBotIdentity.DiedLastRound = npc.isPlayerDead;
					if (Plugin.IsModLethalPhonesLoaded)
					{
						lethalBotAI.StopBeingSwitchboardOperator();
						if (lethalBotAI.AreWeInCall() || lethalBotAI.IsPhoneEquipped())
						{
							lethalBotAI.HangupPhone();
						}
					}
				}
				else
				{
					lethalBotAI.LethalBotIdentity.Status = EnumStatusIdentity.ToSpawn;
					lethalBotAI.LethalBotIdentity.DiedLastRound = npc.isPlayerDead;
					if (lethalBotAI.State != null && lethalBotAI.State.GetAIState() != 0)
					{
						lethalBotAI.State = new BrainDeadState(lethalBotAI);
					}
					if (Plugin.IsModLethalPhonesLoaded)
					{
						lethalBotAI.StopBeingSwitchboardOperator();
						if (lethalBotAI.AreWeInCall() || lethalBotAI.IsPhoneEquipped())
						{
							lethalBotAI.HangupPhone();
						}
						CleanupLethalPhoneForBot(npc);
					}
				}
				if (((NetworkBehaviour)this).IsOwner)
				{
					GroupManager.Instance.RemoveFromCurrentGroupAndSync(npc);
				}
				if (((NetworkBehaviour)this).IsServer || ((NetworkBehaviour)this).IsHost)
				{
					EndOfGameBotStats item = new EndOfGameBotStats(lethalBotAI.LethalBotIdentity, npc, !npc.isPlayerDead);
					AllBotEndOfGameStats.Add(item);
				}
				AllBotPlayerIndexs.Add((int)npc.playerClientId);
			}
		}

		public void MarkBotsAsLoaded()
		{
			StartOfRound instance = StartOfRound.Instance;
			LethalBotAI[] lethalBotAIs = GetLethalBotAIs();
			LethalBotAI[] array = lethalBotAIs;
			foreach (LethalBotAI lethalBotAI in array)
			{
				PlayerControllerB val = lethalBotAI.NpcController?.Npc;
				if ((Object)(object)val != (Object)null && (val.isPlayerControlled || val.isPlayerDead))
				{
					PatchesUtil.PlayerLoadedServerRpcMethod.Invoke(instance, new object[1] { val.actualClientId });
				}
			}
		}

		public void MarkBotsAsLoadedDelayed()
		{
			if (markBotsAsLoadedCoroutine != null)
			{
				((MonoBehaviour)this).StopCoroutine(markBotsAsLoadedCoroutine);
				markBotsAsLoadedCoroutine = null;
			}
			markBotsAsLoadedCoroutine = ((MonoBehaviour)this).StartCoroutine(MarkBotsAsLoadedWhenHumanPlayersReady());
		}

		[IteratorStateMachine(typeof(<MarkBotsAsLoadedWhenHumanPlayersReady>d__205))]
		private IEnumerator MarkBotsAsLoadedWhenHumanPlayersReady()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <MarkBotsAsLoadedWhenHumanPlayersReady>d__205(0)
			{
				<>4__this = this
			};
		}

		public void MarkBotsAsGeneratedFloor()
		{
			RoundManager instance = RoundManager.Instance;
			LethalBotAI[] lethalBotAIs = GetLethalBotAIs();
			LethalBotAI[] array = lethalBotAIs;
			foreach (LethalBotAI lethalBotAI in array)
			{
				PlayerControllerB val = lethalBotAI.NpcController?.Npc;
				if ((Object)(object)val != (Object)null && (val.isPlayerControlled || val.isPlayerDead))
				{
					instance.FinishedGeneratingLevelServerRpc(val.actualClientId);
				}
			}
		}

		public void MarkBotsAsGeneratedFloorDelayed()
		{
			if (markBotsAsGeneratedFloorCoroutine != null)
			{
				((MonoBehaviour)this).StopCoroutine(markBotsAsGeneratedFloorCoroutine);
				markBotsAsGeneratedFloorCoroutine = null;
			}
			markBotsAsGeneratedFloorCoroutine = ((MonoBehaviour)this).StartCoroutine(MarkBotsAsGeneratedFloorWhenHumanPlayersReady());
		}

		[IteratorStateMachine(typeof(<MarkBotsAsGeneratedFloorWhenHumanPlayersReady>d__208))]
		private IEnumerator MarkBotsAsGeneratedFloorWhenHumanPlayersReady()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <MarkBotsAsGeneratedFloorWhenHumanPlayersReady>d__208(0)
			{
				<>4__this = this
			};
		}

		public void EnsureShipNavMeshBuilt()
		{
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			if (shipNavMeshBuilt)
			{
				return;
			}
			GameObject val = GameObject.Find("Environment");
			if (shipNavMeshInstance == null)
			{
				shipNavMeshInstance = Object.Instantiate<GameObject>(GetShipNavPrefab());
			}
			shipNavMeshInstance.SetActive(true);
			shipNavMeshInstance.transform.SetParent(StartOfRound.Instance.elevatorTransform, true);
			if ((Object)(object)val != (Object)null)
			{
				Plugin.LogInfo("Found Environment!");
				shipNavMeshInstance.transform.position = val.transform.position;
				shipNavMeshInstance.transform.rotation = val.transform.rotation;
			}
			else
			{
				Plugin.LogWarning("Failed to find Environment!");
				shipNavMeshInstance.transform.position = new Vector3(-17.43886f, 7.605381f, -16.4713f);
				shipNavMeshInstance.transform.rotation = new Quaternion(0f, 0f, 0f, 1f);
			}
			shipNavMeshSurface = shipNavMeshInstance.GetComponent<NavMeshSurface>();
			((Behaviour)shipNavMeshSurface).enabled = true;
			Plugin.LogInfo("Building ship navmesh...");
			shipNavMeshSurface.BuildNavMesh();
			Plugin.LogInfo("Navmesh built: " + (object)shipNavMeshSurface.navMeshData);
			if ((Object)(object)landingShipNavObstacle == (Object)null)
			{
				NavMeshObstacle[] array = Object.FindObjectsOfType<NavMeshObstacle>();
				NavMeshObstacle[] array2 = array;
				foreach (NavMeshObstacle val2 in array2)
				{
					Plugin.LogInfo($"Obstacle: {val2} with name {((Object)val2).name}: isEnabled {((Behaviour)val2).enabled}");
					if (((Object)val2).name == "LandingShipNavObstacle")
					{
						landingShipNavObstacle = val2;
						landingShipNavObstacleInfo = (val2.height, val2.radius);
						val2.height = 0f;
						val2.radius = 0f;
						break;
					}
				}
			}
			shipNavMeshActive = true;
		}

		public GameObject GetShipNavPrefab()
		{
			return Plugin.ShipOrbitNavMeshPrefab;
		}

		public void EnableShipNavMesh(string reason = "Unknown")
		{
			if (shipNavMeshBuilt && !shipNavMeshActive)
			{
				Plugin.LogDebug("Enabling ship NavMeshSurface object. Reason: " + reason);
				GameObject? obj = shipNavMeshInstance;
				if (obj != null)
				{
					obj.SetActive(true);
				}
				((Behaviour)shipNavMeshSurface).enabled = true;
				shipNavMeshSurface.AddData();
				if (disableNavMeshCoroutine != null)
				{
					((MonoBehaviour)this).StopCoroutine(disableNavMeshCoroutine);
					disableNavMeshCoroutine = null;
				}
				NavMeshObstacle obj2 = landingShipNavObstacle;
				if (obj2 != null)
				{
					obj2.height = 0.01f;
				}
				NavMeshObstacle obj3 = landingShipNavObstacle;
				if (obj3 != null)
				{
					obj3.radius = 0.01f;
				}
				shipNavMeshActive = true;
			}
		}

		public void DisableShipNavMesh(string reason = "Unknown")
		{
			if (!shipNavMeshBuilt || !shipNavMeshActive)
			{
				return;
			}
			Plugin.LogDebug("Disabling ship NavMeshSurface object. Reason: " + reason);
			shipNavMeshSurface.RemoveData();
			GameObject? obj = shipNavMeshInstance;
			if (obj != null)
			{
				obj.SetActive(false);
			}
			((Behaviour)shipNavMeshSurface).enabled = false;
			if (disableNavMeshCoroutine != null)
			{
				((MonoBehaviour)this).StopCoroutine(disableNavMeshCoroutine);
			}
			disableNavMeshCoroutine = ((MonoBehaviour)this).StartCoroutine(ReenableNavMeshBlockerDelayed());
			shipNavMeshActive = false;
			NavMeshLink[] array = Object.FindObjectsOfType<NavMeshLink>();
			Plugin.LogInfo($"Updating all NavMeshLinks! Count: {array.Length}");
			NavMeshLink[] array2 = array;
			foreach (NavMeshLink val in array2)
			{
				if ((Object)(object)val != (Object)null)
				{
					val.UpdateLink();
				}
			}
			OffMeshLink[] array3 = Object.FindObjectsOfType<OffMeshLink>();
			Plugin.LogInfo($"Updating all OffMeshLinks! Count: {array3.Length}");
			OffMeshLink[] array4 = array3;
			foreach (OffMeshLink val2 in array4)
			{
				if ((Object)(object)val2 != (Object)null)
				{
					val2.UpdatePositions();
				}
			}
		}

		[IteratorStateMachine(typeof(<ReenableNavMeshBlockerDelayed>d__213))]
		private IEnumerator ReenableNavMeshBlockerDelayed()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <ReenableNavMeshBlockerDelayed>d__213(0)
			{
				<>4__this = this
			};
		}

		public void SyncEndOfRoundLethalBots(bool preRevive = false)
		{
			if (((NetworkBehaviour)this).IsOwner)
			{
				if (((NetworkBehaviour)this).IsServer)
				{
					SyncEndOfRoundLethalBotsFromServerToClientRpc(preRevive);
				}
				else
				{
					SyncEndOfRoundLethalBotsFromClientToServerRpc(preRevive);
				}
			}
		}

		[ServerRpc]
		private void SyncEndOfRoundLethalBotsFromClientToServerRpc(bool preRevive = false)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Invalid comparison between Unknown and I4
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Invalid comparison between Unknown and I4
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				if (((NetworkBehaviour)this).OwnerClientId != networkManager.LocalClientId)
				{
					if ((int)networkManager.LogLevel <= 1)
					{
						Debug.LogError((object)"Only the owner can invoke a ServerRpc that requires ownership!");
					}
					return;
				}
				ServerRpcParams val = default(ServerRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(2655523674u, val, (RpcDelivery)0);
				((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref preRevive, default(ForPrimitives));
				((NetworkBehaviour)this).__endSendServerRpc(ref val2, 2655523674u, val, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				SyncEndOfRoundLethalBotsFromServerToClientRpc(preRevive);
			}
		}

		[ClientRpc]
		private void SyncEndOfRoundLethalBotsFromServerToClientRpc(bool preRevive = false)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val = default(ClientRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(3320735890u, val, (RpcDelivery)0);
					((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref preRevive, default(ForPrimitives));
					((NetworkBehaviour)this).__endSendClientRpc(ref val2, 3320735890u, val, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					EndOfRoundForLethalBots(preRevive);
				}
			}
		}

		public void VehicleHasLanded()
		{
			VehicleController = Object.FindObjectOfType<VehicleController>();
			Plugin.LogDebug($"Vehicle has landed : {VehicleController}");
		}

		[ServerRpc(RequireOwnership = false)]
		public void SyncLoadedJsonIdentitiesServerRpc(ulong clientId)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_0117: Unknown result type (might be due to invalid IL or missing references)
			//IL_0118: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val = default(ServerRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(4292259290u, val, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val2, clientId);
					((NetworkBehaviour)this).__endSendServerRpc(ref val2, 4292259290u, val, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					Plugin.LogDebug($"Client {clientId} ask server/host {((NetworkBehaviour)this).NetworkManager.LocalClientId} to SyncLoadedJsonIdentities");
					ClientRpcParams.Send = new ClientRpcSendParams
					{
						TargetClientIds = new ulong[1] { clientId }
					};
					SyncLoadedJsonIdentitiesClientRpc(new ConfigIdentitiesNetworkSerializable
					{
						ConfigIdentities = Plugin.Config.ConfigIdentities.configIdentities
					}, ClientRpcParams);
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void SyncLoadedJsonIdentitiesToAllClientsServerRpc()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0142: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				ServerRpcParams val = default(ServerRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(3013741216u, val, (RpcDelivery)0);
				((NetworkBehaviour)this).__endSendServerRpc(ref val2, 3013741216u, val, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				Plugin.LogDebug($"Server/Host {((NetworkBehaviour)this).NetworkManager.LocalClientId} is syncing loaded json identities to all clients");
				ClientRpcParams.Send = new ClientRpcSendParams
				{
					TargetClientIds = ((NetworkBehaviour)this).NetworkManager.ConnectedClientsIds.Where((ulong x) => x != ((NetworkBehaviour)this).NetworkManager.LocalClientId).ToArray()
				};
				SyncLoadedJsonIdentitiesClientRpc(new ConfigIdentitiesNetworkSerializable
				{
					ConfigIdentities = Plugin.Config.ConfigIdentities.configIdentities
				}, ClientRpcParams);
			}
		}

		[ClientRpc]
		private void SyncLoadedJsonIdentitiesClientRpc(ConfigIdentitiesNetworkSerializable configIdentityNetworkSerializable, ClientRpcParams clientRpcParams = default(ClientRpcParams))
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(3548191887u, clientRpcParams, (RpcDelivery)0);
				((FastBufferWriter)(ref val)).WriteValueSafe<ConfigIdentitiesNetworkSerializable>(ref configIdentityNetworkSerializable, default(ForNetworkSerializable));
				((NetworkBehaviour)this).__endSendClientRpc(ref val, 3548191887u, clientRpcParams, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage != 1 || (!networkManager.IsClient && !networkManager.IsHost))
			{
				return;
			}
			base.__rpc_exec_stage = (__RpcExecStage)0;
			if (!((NetworkBehaviour)this).IsOwner)
			{
				Plugin.LogInfo($"Client {((NetworkBehaviour)this).NetworkManager.LocalClientId} : sync json bots identities");
				Plugin.LogDebug($"Loaded {configIdentityNetworkSerializable.ConfigIdentities.Length} identities from server");
				ConfigIdentity[] configIdentities = configIdentityNetworkSerializable.ConfigIdentities;
				for (int i = 0; i < configIdentities.Length; i++)
				{
					ConfigIdentity configIdentity = configIdentities[i];
					Plugin.LogDebug(configIdentity.ToString() ?? "");
				}
				Plugin.LogDebug($"Recreate identities for {configIdentityNetworkSerializable.ConfigIdentities.Length} bots");
				IdentityManager.Instance.InitIdentities(configIdentityNetworkSerializable.ConfigIdentities);
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void SyncLoadedJsonLoadoutsServerRpc(ulong clientId)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_0117: Unknown result type (might be due to invalid IL or missing references)
			//IL_0118: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val = default(ServerRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(700114798u, val, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val2, clientId);
					((NetworkBehaviour)this).__endSendServerRpc(ref val2, 700114798u, val, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					Plugin.LogDebug($"Client {clientId} ask server/host {((NetworkBehaviour)this).NetworkManager.LocalClientId} to SyncLoadedJsonLoadouts");
					ClientRpcParams.Send = new ClientRpcSendParams
					{
						TargetClientIds = new ulong[1] { clientId }
					};
					SyncLoadedJsonLoadoutsClientRpc(new ConfigLoadoutsNetworkSerializable
					{
						ConfigLoadouts = Plugin.Config.ConfigLoadouts.configLoadouts
					}, ClientRpcParams);
				}
			}
		}

		[ClientRpc]
		private void SyncLoadedJsonLoadoutsClientRpc(ConfigLoadoutsNetworkSerializable configLoadoutNetworkSerializable, ClientRpcParams clientRpcParams = default(ClientRpcParams))
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(2288718840u, clientRpcParams, (RpcDelivery)0);
				((FastBufferWriter)(ref val)).WriteValueSafe<ConfigLoadoutsNetworkSerializable>(ref configLoadoutNetworkSerializable, default(ForNetworkSerializable));
				((NetworkBehaviour)this).__endSendClientRpc(ref val, 2288718840u, clientRpcParams, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage != 1 || (!networkManager.IsClient && !networkManager.IsHost))
			{
				return;
			}
			base.__rpc_exec_stage = (__RpcExecStage)0;
			if (!((NetworkBehaviour)this).IsOwner)
			{
				Plugin.LogInfo($"Client {((NetworkBehaviour)this).NetworkManager.LocalClientId} : sync json bots loadouts");
				Plugin.LogDebug($"Loaded {configLoadoutNetworkSerializable.ConfigLoadouts.Length} loadouts from server");
				ConfigLoadout[] configLoadouts = configLoadoutNetworkSerializable.ConfigLoadouts;
				for (int i = 0; i < configLoadouts.Length; i++)
				{
					ConfigLoadout configLoadout = configLoadouts[i];
					Plugin.LogDebug(configLoadout.ToString() ?? "");
				}
				Plugin.LogDebug($"Recreate loadouts for {configLoadoutNetworkSerializable.ConfigLoadouts.Length} bots");
				LoadoutManager.Instance.InitLoadouts(configLoadoutNetworkSerializable.ConfigLoadouts);
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void SyncLoadedJsonStockRequirementsServerRpc(ulong clientId)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_0117: Unknown result type (might be due to invalid IL or missing references)
			//IL_0118: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val = default(ServerRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(2651922194u, val, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val2, clientId);
					((NetworkBehaviour)this).__endSendServerRpc(ref val2, 2651922194u, val, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					Plugin.LogDebug($"Client {clientId} ask server/host {((NetworkBehaviour)this).NetworkManager.LocalClientId} to SyncLoadedJsonStockRequirements");
					ClientRpcParams.Send = new ClientRpcSendParams
					{
						TargetClientIds = new ulong[1] { clientId }
					};
					SyncLoadedJsonStockRequirementsClientRpc(new ConfigStockRequirementNetworkSerializable
					{
						ConfigStockRequirements = Plugin.Config.ConfigStockRequirements.configStockRequirements
					}, ClientRpcParams);
				}
			}
		}

		[ClientRpc]
		private void SyncLoadedJsonStockRequirementsClientRpc(ConfigStockRequirementNetworkSerializable configLoadoutNetworkSerializable, ClientRpcParams clientRpcParams = default(ClientRpcParams))
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(1309261795u, clientRpcParams, (RpcDelivery)0);
				((FastBufferWriter)(ref val)).WriteValueSafe<ConfigStockRequirementNetworkSerializable>(ref configLoadoutNetworkSerializable, default(ForNetworkSerializable));
				((NetworkBehaviour)this).__endSendClientRpc(ref val, 1309261795u, clientRpcParams, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage != 1 || (!networkManager.IsClient && !networkManager.IsHost))
			{
				return;
			}
			base.__rpc_exec_stage = (__RpcExecStage)0;
			if (!((NetworkBehaviour)this).IsOwner)
			{
				Plugin.LogInfo($"Client {((NetworkBehaviour)this).NetworkManager.LocalClientId} : sync json bots stock requirements");
				Plugin.LogDebug($"Loaded {configLoadoutNetworkSerializable.ConfigStockRequirements.Length} stock requirements from server");
				ConfigStockRequirement[] configStockRequirements = configLoadoutNetworkSerializable.ConfigStockRequirements;
				for (int i = 0; i < configStockRequirements.Length; i++)
				{
					ConfigStockRequirement configStockRequirement = configStockRequirements[i];
					Plugin.LogDebug(configStockRequirement.ToString() ?? "");
				}
				Plugin.LogDebug($"Recreate stock requirements for {configLoadoutNetworkSerializable.ConfigStockRequirements.Length} bots");
				RestockManager.Instance.InitStockRequirements(configLoadoutNetworkSerializable.ConfigStockRequirements);
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void SyncLethalBotsToJoiningPlayerServerRpc(ulong clientId)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_0117: Unknown result type (might be due to invalid IL or missing references)
			//IL_0118: Unknown result type (might be due to invalid IL or missing references)
			//IL_0248: Unknown result type (might be due to invalid IL or missing references)
			//IL_0166: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ac: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				ServerRpcParams val = default(ServerRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(3788476863u, val, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val2, clientId);
				((NetworkBehaviour)this).__endSendServerRpc(ref val2, 3788476863u, val, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage != 1 || (!networkManager.IsServer && !networkManager.IsHost))
			{
				return;
			}
			base.__rpc_exec_stage = (__RpcExecStage)0;
			Plugin.LogDebug($"Client {clientId} ask server/host {((NetworkBehaviour)this).NetworkManager.LocalClientId} to SyncLethalBots");
			ClientRpcParams.Send = new ClientRpcSendParams
			{
				TargetClientIds = new ulong[1] { clientId }
			};
			SpawnLethalBotParamsNetworkSerializable[] array = new SpawnLethalBotParamsNetworkSerializable[AllLethalBotAIs.Length];
			for (int i = 0; i < AllLethalBotAIs.Length; i++)
			{
				LethalBotAI lethalBotAI = AllLethalBotAIs[i];
				if ((Object)(object)lethalBotAI == (Object)null)
				{
					array[i] = new SpawnLethalBotParamsNetworkSerializable();
					continue;
				}
				int num = i;
				SpawnLethalBotParamsNetworkSerializable spawnLethalBotParamsNetworkSerializable = new SpawnLethalBotParamsNetworkSerializable
				{
					LethalBotReference = NetworkObjectReference.op_Implicit(((NetworkBehaviour)lethalBotAI).NetworkObject),
					IndexNextLethalBot = i,
					IndexNextPlayerObject = i
				};
				NpcController npcController = lethalBotAI.NpcController;
				spawnLethalBotParamsNetworkSerializable.SpawnPosition = ((npcController != null) ? new Vector3?(((Component)npcController.Npc).transform.position) : null);
				spawnLethalBotParamsNetworkSerializable.LethalBotIdentityID = lethalBotAI.LethalBotIdentity.IdIdentity;
				spawnLethalBotParamsNetworkSerializable.enumSpawnAnimation = EnumSpawnAnimation.ReinitializePlayer;
				spawnLethalBotParamsNetworkSerializable.SuitID = lethalBotAI.LethalBotIdentity.SuitID.GetValueOrDefault();
				spawnLethalBotParamsNetworkSerializable.CarryWeight = lethalBotAI.NpcController?.Npc?.carryWeight;
				array[num] = spawnLethalBotParamsNetworkSerializable;
			}
			SyncLethalBotsToJoiningPlayerClientRpc(array, ClientRpcParams);
		}

		[ClientRpc]
		private void SyncLethalBotsToJoiningPlayerClientRpc(SpawnLethalBotParamsNetworkSerializable[] spawnLethalBotParamsNetworkSerializable, ClientRpcParams clientRpcParams = default(ClientRpcParams))
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: 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_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(3373517389u, clientRpcParams, (RpcDelivery)0);
				bool flag = spawnLethalBotParamsNetworkSerializable != null;
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				if (flag)
				{
					((FastBufferWriter)(ref val)).WriteValueSafe<SpawnLethalBotParamsNetworkSerializable>(spawnLethalBotParamsNetworkSerializable, default(ForNetworkSerializable));
				}
				((NetworkBehaviour)this).__endSendClientRpc(ref val, 3373517389u, clientRpcParams, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage != 1 || (!networkManager.IsClient && !networkManager.IsHost))
			{
				return;
			}
			base.__rpc_exec_stage = (__RpcExecStage)0;
			if (!((NetworkBehaviour)this).IsServer && !((NetworkBehaviour)this).IsHost)
			{
				if (AreWeInOrbit())
				{
					EnsureShipNavMeshBuilt();
					EnableShipNavMesh();
				}
				((MonoBehaviour)this).StartCoroutine(SyncLethalBotsToJoiningPlayer(spawnLethalBotParamsNetworkSerializable));
			}
		}

		[IteratorStateMachine(typeof(<SyncLethalBotsToJoiningPlayer>d__227))]
		private IEnumerator SyncLethalBotsToJoiningPlayer(SpawnLethalBotParamsNetworkSerializable[] spawnLethalBotParamsNetworkSerializable)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <SyncLethalBotsToJoiningPlayer>d__227(0)
			{
				<>4__this = this,
				spawnLethalBotParamsNetworkSerializable = spawnLethalBotParamsNetworkSerializable
			};
		}

		public void UpdateAllLethalBotsVoiceEffects()
		{
			LethalBotAI[] allLethalBotAIs = AllLethalBotAIs;
			foreach (LethalBotAI lethalBotAI in allLethalBotAIs)
			{
				if (!((Object)(object)lethalBotAI == (Object)null) && ((NetworkBehaviour)lethalBotAI).IsSpawned && lethalBotAI.NpcController != null && !((Object)(object)((EnemyAI)lethalBotAI).creatureVoice == (Object)null) && (lethalBotAI.NpcController.Npc.isPlayerDead || lethalBotAI.NpcController.Npc.isPlayerControlled))
				{
					lethalBotAI.UpdateLethalBotVoiceEffects();
				}
			}
		}

		public bool DidAnLethalBotJustTalkedClose(int idLethalBotTryingToTalk)
		{
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			LethalBotAI lethalBotAI = AllLethalBotAIs[idLethalBotTryingToTalk];
			LethalBotAI[] allLethalBotAIs = AllLethalBotAIs;
			foreach (LethalBotAI lethalBotAI2 in allLethalBotAIs)
			{
				if (!((Object)(object)lethalBotAI2 == (Object)null) && ((NetworkBehaviour)lethalBotAI2).IsSpawned && lethalBotAI2.NpcController != null && (lethalBotAI2.NpcController.Npc.isPlayerDead || lethalBotAI2.NpcController.Npc.isPlayerControlled) && !((Object)(object)lethalBotAI2 == (Object)(object)lethalBotAI) && lethalBotAI2.LethalBotIdentity.Voice.IsTalking())
				{
					Vector3 val = ((Component)lethalBotAI2.NpcController.Npc).transform.position - ((Component)lethalBotAI.NpcController.Npc).transform.position;
					if (((Vector3)(ref val)).sqrMagnitude < 100f)
					{
						return true;
					}
				}
			}
			return false;
		}

		public void SyncPlayAudioLethalBot(int lethalBotID, string smallPathAudioClip)
		{
			AllLethalBotAIs[lethalBotID].PlayAudioServerRpc(smallPathAudioClip, Plugin.Config.Talkativeness.Value);
		}

		public void PlayAudibleNoiseForLethalBot(int lethalBotID, Vector3 noisePosition, float noiseRange = 10f, float noiseLoudness = 0.5f, int noiseID = 0)
		{
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			LethalBotAI lethalBotAI = AllLethalBotAIs[lethalBotID];
			bool noiseIsInsideClosedShip = lethalBotAI.NpcController.Npc.isInHangarShipRoom && lethalBotAI.NpcController.Npc.playersManager.hangarDoorsClosed;
			lethalBotAI.NpcController.PlayAudibleNoiseLethalBot(noisePosition, noiseRange, noiseLoudness, 0, noiseIsInsideClosedShip, noiseID);
		}

		[ServerRpc(RequireOwnership = false)]
		public void UpdateReviveCountServerRpc(int id)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val = default(ServerRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(2106849743u, val, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val2, id);
					((NetworkBehaviour)this).__endSendServerRpc(ref val2, 2106849743u, val, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					UpdateReviveCountClientRpc(id);
				}
			}
		}

		[ClientRpc]
		private void UpdateReviveCountClientRpc(int id)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val = default(ClientRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(1502255224u, val, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val2, id);
					((NetworkBehaviour)this).__endSendClientRpc(ref val2, 1502255224u, val, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					BunkbedController.UpdateReviveCount(id);
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void SyncGroupCreditsForNotOwnerTerminalServerRpc(int newGroupCredits, int numItemsInShip)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: 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_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val = default(ServerRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(774372827u, val, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val2, newGroupCredits);
					BytePacker.WriteValueBitPacked(val2, numItemsInShip);
					((NetworkBehaviour)this).__endSendServerRpc(ref val2, 774372827u, val, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					Terminal terminal = TerminalManager.Instance.GetTerminal();
					terminal.SyncGroupCreditsServerRpc(newGroupCredits, numItemsInShip);
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void UpdateReviveCompanyRemainingRevivesServerRpc(string identityName)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: 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_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				ServerRpcParams val = default(ServerRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(1208558443u, val, (RpcDelivery)0);
				bool flag = identityName != null;
				((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				if (flag)
				{
					((FastBufferWriter)(ref val2)).WriteValueSafe(identityName, false);
				}
				((NetworkBehaviour)this).__endSendServerRpc(ref val2, 1208558443u, val, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				UpdateReviveCompanyRemainingRevivesClientRpc(identityName);
			}
		}

		[ClientRpc]
		private void UpdateReviveCompanyRemainingRevivesClientRpc(string identityName)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: 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_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val = default(ClientRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(4031719329u, val, (RpcDelivery)0);
				bool flag = identityName != null;
				((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				if (flag)
				{
					((FastBufferWriter)(ref val2)).WriteValueSafe(identityName, false);
				}
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 4031719329u, val, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				GlobalVariables.RemainingRevives--;
				if (GlobalVariables.RemainingRevives < 100)
				{
					HUDManager.Instance.DisplayTip(identityName + " was revived", $"{GlobalVariables.RemainingRevives} revives remain!", false, false, "LC_Tip1");
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void SetStartingRevivesReviveCompanyServerRpc()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val = default(ServerRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(3312171593u, val, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendServerRpc(ref val2, 3312171593u, val, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					SetStartingRevivesReviveCompanyClientRpc();
				}
			}
		}

		[ClientRpc]
		private void SetStartingRevivesReviveCompanyClientRpc()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val = default(ClientRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(965672077u, val, (RpcDelivery)0);
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 965672077u, val, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				if (Plugin.IsModReviveCompanyLoaded)
				{
					SetStartingRevivesReviveCompany();
				}
			}
		}

		private void SetStartingRevivesReviveCompany()
		{
			try
			{
				Type type = AccessTools.TypeByName("OPJosMod.ReviveCompany.Patches.StartOfRoundPatch");
				if (type != null)
				{
					MethodInfo methodInfo = AccessTools.Method(type, "setStartingRevives", (Type[])null, (Type[])null);
					if (methodInfo != null)
					{
						methodInfo.Invoke(null, null);
						Plugin.LogDebug("Successfully invoked setStartingRevives via AccessTools.");
					}
					else
					{
						Plugin.LogWarning("Could not find setStartingRevives method.");
					}
				}
				else
				{
					Plugin.LogWarning("Could not find StartOfRoundPatch type from ReviveCompany.");
				}
			}
			catch (Exception arg)
			{
				Plugin.LogError($"Error while invoking seting base available revives: {arg}");
			}
		}

		public void SetMissionControllerAndSync(NetworkBehaviourReference playerToSync)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			if (((NetworkBehaviour)this).IsServer)
			{
				_missionControlPlayer.Value = playerToSync;
			}
			else
			{
				SetMissionControllerServerRpc(playerToSync);
			}
		}

		[ServerRpc(RequireOwnership = false)]
		private void SetMissionControllerServerRpc(NetworkBehaviourReference playerToSync)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val = default(ServerRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(306000109u, val, (RpcDelivery)0);
					((FastBufferWriter)(ref val2)).WriteValueSafe<NetworkBehaviourReference>(ref playerToSync, default(ForNetworkSerializable));
					((NetworkBehaviour)this).__endSendServerRpc(ref val2, 306000109u, val, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					SetMissionControllerAndSync(playerToSync);
				}
			}
		}

		public void AddPlayerToLootTransferListAndSync(NetworkBehaviourReference playerToAdd)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			if (((NetworkBehaviour)this).IsServer)
			{
				if (!LootTransferPlayers.Contains(playerToAdd))
				{
					LootTransferPlayers.Add(playerToAdd);
				}
			}
			else
			{
				AddPlayerToLootTransferListServerRpc(playerToAdd);
			}
		}

		public void RemovePlayerFromLootTransferListAndSync(NetworkBehaviourReference playerToRemove)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			if (((NetworkBehaviour)this).IsServer)
			{
				LootTransferPlayers.Remove(playerToRemove);
			}
			else
			{
				RemovePlayerFromLootTransferListServerRpc(playerToRemove);
			}
		}

		[ServerRpc(RequireOwnership = false)]
		private void AddPlayerToLootTransferListServerRpc(NetworkBehaviourReference playerToAdd)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val = default(ServerRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(1022940860u, val, (RpcDelivery)0);
					((FastBufferWriter)(ref val2)).WriteValueSafe<NetworkBehaviourReference>(ref playerToAdd, default(ForNetworkSerializable));
					((NetworkBehaviour)this).__endSendServerRpc(ref val2, 1022940860u, val, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					AddPlayerToLootTransferListAndSync(playerToAdd);
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		private void RemovePlayerFromLootTransferListServerRpc(NetworkBehaviourReference playerToRemove)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val = default(ServerRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(3935232259u, val, (RpcDelivery)0);
					((FastBufferWriter)(ref val2)).WriteValueSafe<NetworkBehaviourReference>(ref playerToRemove, default(ForNetworkSerializable));
					((NetworkBehaviour)this).__endSendServerRpc(ref val2, 3935232259u, val, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					RemovePlayerFromLootTransferListAndSync(playerToRemove);
				}
			}
		}

		public void SetLastReportedTimeOfDayAndSync(DayMode timeOfDay)
		{
			//IL_0001: 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_0010: Unknown result type (might be due to invalid IL or missing references)
			SetLastReportedTimeOfDay(timeOfDay);
			if (((NetworkBehaviour)this).IsServer)
			{
				SetLastReportedTimeOfDayClientRpc(timeOfDay);
			}
			else
			{
				SetLastReportedTimeOfDayServerRpc(timeOfDay);
			}
		}

		[ServerRpc(RequireOwnership = false)]
		private void SetLastReportedTimeOfDayServerRpc(DayMode timeOfDay)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val = default(ServerRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(4064771903u, val, (RpcDelivery)0);
					((FastBufferWriter)(ref val2)).WriteValueSafe<DayMode>(ref timeOfDay, default(ForEnums));
					((NetworkBehaviour)this).__endSendServerRpc(ref val2, 4064771903u, val, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					SetLastReportedTimeOfDayClientRpc(timeOfDay);
				}
			}
		}

		[ClientRpc]
		private void SetLastReportedTimeOfDayClientRpc(DayMode timeOfDay)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val = default(ClientRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(1248913442u, val, (RpcDelivery)0);
					((FastBufferWriter)(ref val2)).WriteValueSafe<DayMode>(ref timeOfDay, default(ForEnums));
					((NetworkBehaviour)this).__endSendClientRpc(ref val2, 1248913442u, val, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					SetLastReportedTimeOfDay(timeOfDay);
				}
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private void SetLastReportedTimeOfDay(DayMode timeOfDay)
		{
			//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)
			lastReportedTimeOfDay = timeOfDay;
		}

		protected override void __initializeVariables()
		{
			if (botSpawned == null)
			{
				throw new Exception("LethalBotManager.botSpawned cannot be null. All NetworkVariableBase instances must be initialized.");
			}
			((NetworkVariableBase)botSpawned).Initialize((NetworkBehaviour)(object)this);
			((NetworkBehaviour)this).__nameNetworkVariable((NetworkVariableBase)(object)botSpawned, "botSpawned");
			base.NetworkVariableFields.Add((NetworkVariableBase)(object)botSpawned);
			if (sendPlayerCountUpdate == null)
			{
				throw new Exception("LethalBotManager.sendPlayerCountUpdate cannot be null. All NetworkVariableBase instances must be initialized.");
			}
			((NetworkVariableBase)sendPlayerCountUpdate).Initialize((NetworkBehaviour)(object)this);
			((NetworkBehaviour)this).__nameNetworkVariable((NetworkVariableBase)(object)sendPlayerCountUpdate, "sendPlayerCountUpdate");
			base.NetworkVariableFields.Add((NetworkVariableBase)(object)sendPlayerCountUpdate);
			if (isSpawningBots == null)
			{
				throw new Exception("LethalBotManager.isSpawningBots cannot be null. All NetworkVariableBase instances must be initialized.");
			}
			((NetworkVariableBase)isSpawningBots).Initialize((NetworkBehaviour)(object)this);
			((NetworkBehaviour)this).__nameNetworkVariable((NetworkVariableBase)(object)isSpawningBots, "isSpawningBots");
			base.NetworkVariableFields.Add((NetworkVariableBase)(object)isSpawningBots);
			if (blacklistedNetworkList == null)
			{
				throw new Exception("LethalBotManager.blacklistedNetworkList cannot be null. All NetworkVariableBase instances must be initialized.");
			}
			((NetworkVariableBase)blacklistedNetworkList).Initialize((NetworkBehaviour)(object)this);
			((NetworkBehaviour)this).__nameNetworkVariable((NetworkVariableBase)(object)blacklistedNetworkList, "blacklistedNetworkList");
			base.NetworkVariableFields.Add((NetworkVariableBase)(object)blacklistedNetworkList);
			if (_missionControlPlayer == null)
			{
				throw new Exception("LethalBotManager._missionControlPlayer cannot be null. All NetworkVariableBase instances must be initialized.");
			}
			((NetworkVariableBase)_missionControlPlayer).Initialize((NetworkBehaviour)(object)this);
			((NetworkBehaviour)this).__nameNetworkVariable((NetworkVariableBase)(object)_missionControlPlayer, "_missionControlPlayer");
			base.NetworkVariableFields.Add((NetworkVariableBase)(object)_missionControlPlayer);
			if (LootTransferPlayers == null)
			{
				throw new Exception("LethalBotManager.LootTransferPlayers cannot be null. All NetworkVariableBase instances must be initialized.");
			}
			((NetworkVariableBase)LootTransferPlayers).Initialize((NetworkBehaviour)(object)this);
			((NetworkBehaviour)this).__nameNetworkVariable((NetworkVariableBase)(object)LootTransferPlayers, "LootTransferPlayers");
			base.NetworkVariableFields.Add((NetworkVariableBase)(object)LootTransferPlayers);
			((NetworkBehaviour)this).__initializeVariables();
		}

		protected override void __initializeRpcs()
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Expected O, but got Unknown
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Expected O, but got Unknown
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Expected O, but got Unknown
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Expected O, but got Unknown
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Expected O, but got Unknown
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Expected O, but got Unknown
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Expected O, but got Unknown
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Expected O, but got Unknown
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Expected O, but got Unknown
			//IL_0109: Unknown result type (might be due to invalid IL or missing references)
			//IL_0118: Expected O, but got Unknown
			//IL_0125: Unknown result type (might be due to invalid IL or missing references)
			//IL_0134: Expected O, but got Unknown
			//IL_0141: Unknown result type (might be due to invalid IL or missing references)
			//IL_0150: Expected O, but got Unknown
			//IL_015d: Unknown result type (might be due to invalid IL or missing references)
			//IL_016c: Expected O, but got Unknown
			//IL_0179: Unknown result type (might be due to invalid IL or missing references)
			//IL_0188: Expected O, but got Unknown
			//IL_0195: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a4: Expected O, but got Unknown
			//IL_01b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c0: Expected O, but got Unknown
			//IL_01cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dc: Expected O, but got Unknown
			//IL_01e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f8: Expected O, but got Unknown
			//IL_0205: Unknown result type (might be due to invalid IL or missing references)
			//IL_0214: Expected O, but got Unknown
			//IL_0221: Unknown result type (might be due to invalid IL or missing references)
			//IL_0230: Expected O, but got Unknown
			//IL_023d: Unknown result type (might be due to invalid IL or missing references)
			//IL_024c: Expected O, but got Unknown
			//IL_0259: Unknown result type (might be due to invalid IL or missing references)
			//IL_0268: Expected O, but got Unknown
			//IL_0275: Unknown result type (might be due to invalid IL or missing references)
			//IL_0284: Expected O, but got Unknown
			//IL_0291: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a0: Expected O, but got Unknown
			//IL_02ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bc: Expected O, but got Unknown
			//IL_02c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d8: Expected O, but got Unknown
			//IL_02e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f4: Expected O, but got Unknown
			//IL_0301: Unknown result type (might be due to invalid IL or missing references)
			//IL_0310: Expected O, but got Unknown
			//IL_031d: Unknown result type (might be due to invalid IL or missing references)
			//IL_032c: Expected O, but got Unknown
			//IL_0339: Unknown result type (might be due to invalid IL or missing references)
			//IL_0348: Expected O, but got Unknown
			//IL_0355: Unknown result type (might be due to invalid IL or missing references)
			//IL_0364: Expected O, but got Unknown
			//IL_0371: Unknown result type (might be due to invalid IL or missing references)
			//IL_0380: Expected O, but got Unknown
			//IL_038d: Unknown result type (might be due to invalid IL or missing references)
			//IL_039c: Expected O, but got Unknown
			//IL_03a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b8: Expected O, but got Unknown
			//IL_03c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d4: Expected O, but got Unknown
			//IL_03e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f0: Expected O, but got Unknown
			//IL_03fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_040c: Expected O, but got Unknown
			//IL_0419: Unknown result type (might be due to invalid IL or missing references)
			//IL_0428: Expected O, but got Unknown
			//IL_0435: Unknown result type (might be due to invalid IL or missing references)
			//IL_0444: Expected O, but got Unknown
			//IL_0451: Unknown result type (might be due to invalid IL or missing references)
			//IL_0460: Expected O, but got Unknown
			//IL_046d: Unknown result type (might be due to invalid IL or missing references)
			//IL_047c: Expected O, but got Unknown
			//IL_0489: Unknown result type (might be due to invalid IL or missing references)
			//IL_0498: Expected O, but got Unknown
			//IL_04a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_04b4: Expected O, but got Unknown
			//IL_04c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_04d0: Expected O, but got Unknown
			//IL_04dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ec: Expected O, but got Unknown
			((NetworkBehaviour)this).__registerRpc(233959231u, new RpcReceiveHandler(__rpc_handler_233959231), "DisplayTipClientRpc");
			((NetworkBehaviour)this).__registerRpc(3128040487u, new RpcReceiveHandler(__rpc_handler_3128040487), "RegisterItemAsBlacklistedServerRpc");
			((NetworkBehaviour)this).__registerRpc(1562394522u, new RpcReceiveHandler(__rpc_handler_1562394522), "RegisterItemsAsBlacklistedServerRpc");
			((NetworkBehaviour)this).__registerRpc(2605433549u, new RpcReceiveHandler(__rpc_handler_2605433549), "RemoveItemFromBlacklistServerRpc");
			((NetworkBehaviour)this).__registerRpc(4229823977u, new RpcReceiveHandler(__rpc_handler_4229823977), "RemoveItemsFromBlacklistServerRpc");
			((NetworkBehaviour)this).__registerRpc(1499736859u, new RpcReceiveHandler(__rpc_handler_1499736859), "SpawnLethalBotServerRpc");
			((NetworkBehaviour)this).__registerRpc(1902467509u, new RpcReceiveHandler(__rpc_handler_1902467509), "SpawnThisLethalBotServerRpc");
			((NetworkBehaviour)this).__registerRpc(4279964955u, new RpcReceiveHandler(__rpc_handler_4279964955), "SpawnLethalBotClientRpc");
			((NetworkBehaviour)this).__registerRpc(1204273602u, new RpcReceiveHandler(__rpc_handler_1204273602), "ReinitSpawnedBotServerRpc");
			((NetworkBehaviour)this).__registerRpc(1169342065u, new RpcReceiveHandler(__rpc_handler_1169342065), "ReinitSpawnedBotClientRpc");
			((NetworkBehaviour)this).__registerRpc(3450665584u, new RpcReceiveHandler(__rpc_handler_3450665584), "LethalBotKickedServerRpc");
			((NetworkBehaviour)this).__registerRpc(1393535500u, new RpcReceiveHandler(__rpc_handler_1393535500), "LethalBotKickedClientRpc");
			((NetworkBehaviour)this).__registerRpc(964754010u, new RpcReceiveHandler(__rpc_handler_964754010), "TransmitVoiceChatToAllClientsServerRpc");
			((NetworkBehaviour)this).__registerRpc(1045654173u, new RpcReceiveHandler(__rpc_handler_1045654173), "TransmitVoiceChatToAllClientsClientRpc");
			((NetworkBehaviour)this).__registerRpc(2251955273u, new RpcReceiveHandler(__rpc_handler_2251955273), "UpdateLethalBotsXPServerRpc");
			((NetworkBehaviour)this).__registerRpc(4055705094u, new RpcReceiveHandler(__rpc_handler_4055705094), "UpdateLethalBotsXPClientRpc");
			((NetworkBehaviour)this).__registerRpc(3828485747u, new RpcReceiveHandler(__rpc_handler_3828485747), "SendNewPlayerCountServerRpc");
			((NetworkBehaviour)this).__registerRpc(765310706u, new RpcReceiveHandler(__rpc_handler_765310706), "SendNewPlayerCountClientRpc");
			((NetworkBehaviour)this).__registerRpc(3244699581u, new RpcReceiveHandler(__rpc_handler_3244699581), "RequestPlayerCountServerRpc");
			((NetworkBehaviour)this).__registerRpc(2483945957u, new RpcReceiveHandler(__rpc_handler_2483945957), "RequestPlayerCountClientRpc");
			((NetworkBehaviour)this).__registerRpc(2917048395u, new RpcReceiveHandler(__rpc_handler_2917048395), "SetHangarShipDoorStateServerRpc");
			((NetworkBehaviour)this).__registerRpc(611045299u, new RpcReceiveHandler(__rpc_handler_611045299), "SetHangarShipDoorStateClientRpc");
			((NetworkBehaviour)this).__registerRpc(2655523674u, new RpcReceiveHandler(__rpc_handler_2655523674), "SyncEndOfRoundLethalBotsFromClientToServerRpc");
			((NetworkBehaviour)this).__registerRpc(3320735890u, new RpcReceiveHandler(__rpc_handler_3320735890), "SyncEndOfRoundLethalBotsFromServerToClientRpc");
			((NetworkBehaviour)this).__registerRpc(4292259290u, new RpcReceiveHandler(__rpc_handler_4292259290), "SyncLoadedJsonIdentitiesServerRpc");
			((NetworkBehaviour)this).__registerRpc(3013741216u, new RpcReceiveHandler(__rpc_handler_3013741216), "SyncLoadedJsonIdentitiesToAllClientsServerRpc");
			((NetworkBehaviour)this).__registerRpc(3548191887u, new RpcReceiveHandler(__rpc_handler_3548191887), "SyncLoadedJsonIdentitiesClientRpc");
			((NetworkBehaviour)this).__registerRpc(700114798u, new RpcReceiveHandler(__rpc_handler_700114798), "SyncLoadedJsonLoadoutsServerRpc");
			((NetworkBehaviour)this).__registerRpc(2288718840u, new RpcReceiveHandler(__rpc_handler_2288718840), "SyncLoadedJsonLoadoutsClientRpc");
			((NetworkBehaviour)this).__registerRpc(2651922194u, new RpcReceiveHandler(__rpc_handler_2651922194), "SyncLoadedJsonStockRequirementsServerRpc");
			((NetworkBehaviour)this).__registerRpc(1309261795u, new RpcReceiveHandler(__rpc_handler_1309261795), "SyncLoadedJsonStockRequirementsClientRpc");
			((NetworkBehaviour)this).__registerRpc(3788476863u, new RpcReceiveHandler(__rpc_handler_3788476863), "SyncLethalBotsToJoiningPlayerServerRpc");
			((NetworkBehaviour)this).__registerRpc(3373517389u, new RpcReceiveHandler(__rpc_handler_3373517389), "SyncLethalBotsToJoiningPlayerClientRpc");
			((NetworkBehaviour)this).__registerRpc(2106849743u, new RpcReceiveHandler(__rpc_handler_2106849743), "UpdateReviveCountServerRpc");
			((NetworkBehaviour)this).__registerRpc(1502255224u, new RpcReceiveHandler(__rpc_handler_1502255224), "UpdateReviveCountClientRpc");
			((NetworkBehaviour)this).__registerRpc(774372827u, new RpcReceiveHandler(__rpc_handler_774372827), "SyncGroupCreditsForNotOwnerTerminalServerRpc");
			((NetworkBehaviour)this).__registerRpc(1208558443u, new RpcReceiveHandler(__rpc_handler_1208558443), "UpdateReviveCompanyRemainingRevivesServerRpc");
			((NetworkBehaviour)this).__registerRpc(4031719329u, new RpcReceiveHandler(__rpc_handler_4031719329), "UpdateReviveCompanyRemainingRevivesClientRpc");
			((NetworkBehaviour)this).__registerRpc(3312171593u, new RpcReceiveHandler(__rpc_handler_3312171593), "SetStartingRevivesReviveCompanyServerRpc");
			((NetworkBehaviour)this).__registerRpc(965672077u, new RpcReceiveHandler(__rpc_handler_965672077), "SetStartingRevivesReviveCompanyClientRpc");
			((NetworkBehaviour)this).__registerRpc(306000109u, new RpcReceiveHandler(__rpc_handler_306000109), "SetMissionControllerServerRpc");
			((NetworkBehaviour)this).__registerRpc(1022940860u, new RpcReceiveHandler(__rpc_handler_1022940860), "AddPlayerToLootTransferListServerRpc");
			((NetworkBehaviour)this).__registerRpc(3935232259u, new RpcReceiveHandler(__rpc_handler_3935232259), "RemovePlayerFromLootTransferListServerRpc");
			((NetworkBehaviour)this).__registerRpc(4064771903u, new RpcReceiveHandler(__rpc_handler_4064771903), "SetLastReportedTimeOfDayServerRpc");
			((NetworkBehaviour)this).__registerRpc(1248913442u, new RpcReceiveHandler(__rpc_handler_1248913442), "SetLastReportedTimeOfDayClientRpc");
			((NetworkBehaviour)this).__initializeRpcs();
		}

		private static void __rpc_handler_233959231(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				bool flag = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
				string headerText = null;
				if (flag)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe(ref headerText, false);
				}
				bool flag2 = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag2, default(ForPrimitives));
				string bodyText = null;
				if (flag2)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe(ref bodyText, false);
				}
				ClientRpcParams client = rpcParams.Client;
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((LethalBotManager)(object)target).DisplayTipClientRpc(headerText, bodyText, client);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3128040487(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				NetworkObjectReference itemToBlacklist = default(NetworkObjectReference);
				((FastBufferReader)(ref reader)).ReadValueSafe<NetworkObjectReference>(ref itemToBlacklist, default(ForNetworkSerializable));
				ServerRpcParams server = rpcParams.Server;
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((LethalBotManager)(object)target).RegisterItemAsBlacklistedServerRpc(itemToBlacklist, server);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1562394522(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: 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_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				bool flag = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
				NetworkObjectReference[] itemsToBlacklist = null;
				if (flag)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe<NetworkObjectReference>(ref itemsToBlacklist, default(ForNetworkSerializable));
				}
				ServerRpcParams server = rpcParams.Server;
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((LethalBotManager)(object)target).RegisterItemsAsBlacklistedServerRpc(itemsToBlacklist, server);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2605433549(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				NetworkObjectReference itemToBlacklist = default(NetworkObjectReference);
				((FastBufferReader)(ref reader)).ReadValueSafe<NetworkObjectReference>(ref itemToBlacklist, default(ForNetworkSerializable));
				ServerRpcParams server = rpcParams.Server;
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((LethalBotManager)(object)target).RemoveItemFromBlacklistServerRpc(itemToBlacklist, server);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_4229823977(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: 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_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				bool flag = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
				NetworkObjectReference[] itemsToBlacklist = null;
				if (flag)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe<NetworkObjectReference>(ref itemsToBlacklist, default(ForNetworkSerializable));
				}
				ServerRpcParams server = rpcParams.Server;
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((LethalBotManager)(object)target).RemoveItemsFromBlacklistServerRpc(itemsToBlacklist, server);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1499736859(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				SpawnLethalBotParamsNetworkSerializable spawnLethalBotsParamsNetworkSerializable = default(SpawnLethalBotParamsNetworkSerializable);
				((FastBufferReader)(ref reader)).ReadValueSafe<SpawnLethalBotParamsNetworkSerializable>(ref spawnLethalBotsParamsNetworkSerializable, default(ForNetworkSerializable));
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((LethalBotManager)(object)target).SpawnLethalBotServerRpc(spawnLethalBotsParamsNetworkSerializable);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1902467509(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int identityID = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref identityID);
				SpawnLethalBotParamsNetworkSerializable spawnLethalBotsParamsNetworkSerializable = default(SpawnLethalBotParamsNetworkSerializable);
				((FastBufferReader)(ref reader)).ReadValueSafe<SpawnLethalBotParamsNetworkSerializable>(ref spawnLethalBotsParamsNetworkSerializable, default(ForNetworkSerializable));
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((LethalBotManager)(object)target).SpawnThisLethalBotServerRpc(identityID, spawnLethalBotsParamsNetworkSerializable);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_4279964955(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				NetworkObjectReference networkObjectReferenceLethalBotAI = default(NetworkObjectReference);
				((FastBufferReader)(ref reader)).ReadValueSafe<NetworkObjectReference>(ref networkObjectReferenceLethalBotAI, default(ForNetworkSerializable));
				SpawnLethalBotParamsNetworkSerializable spawnParamsNetworkSerializable = default(SpawnLethalBotParamsNetworkSerializable);
				((FastBufferReader)(ref reader)).ReadValueSafe<SpawnLethalBotParamsNetworkSerializable>(ref spawnParamsNetworkSerializable, default(ForNetworkSerializable));
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((LethalBotManager)(object)target).SpawnLethalBotClientRpc(networkObjectReferenceLethalBotAI, spawnParamsNetworkSerializable);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1204273602(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				NetworkObjectReference networkObjectReferenceLethalBotAI = default(NetworkObjectReference);
				((FastBufferReader)(ref reader)).ReadValueSafe<NetworkObjectReference>(ref networkObjectReferenceLethalBotAI, default(ForNetworkSerializable));
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((LethalBotManager)(object)target).ReinitSpawnedBotServerRpc(networkObjectReferenceLethalBotAI);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1169342065(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				NetworkObjectReference networkObjectReferenceLethalBotAI = default(NetworkObjectReference);
				((FastBufferReader)(ref reader)).ReadValueSafe<NetworkObjectReference>(ref networkObjectReferenceLethalBotAI, default(ForNetworkSerializable));
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((LethalBotManager)(object)target).ReinitSpawnedBotClientRpc(networkObjectReferenceLethalBotAI);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3450665584(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int indexLethalBotAI = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref indexLethalBotAI);
				ServerRpcParams server = rpcParams.Server;
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((LethalBotManager)(object)target).LethalBotKickedServerRpc(indexLethalBotAI, server);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1393535500(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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_0050: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int indexLethalBotAI = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref indexLethalBotAI);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((LethalBotManager)(object)target).LethalBotKickedClientRpc(indexLethalBotAI);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_964754010(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				bool flag = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
				string message = null;
				if (flag)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe(ref message, false);
				}
				int playerId = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref playerId);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((LethalBotManager)(object)target).TransmitVoiceChatToAllClientsServerRpc(message, playerId);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1045654173(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				bool flag = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
				string message = null;
				if (flag)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe(ref message, false);
				}
				int playerId = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref playerId);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((LethalBotManager)(object)target).TransmitVoiceChatToAllClientsClientRpc(message, playerId);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2251955273(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int playerId = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref playerId);
				int newIdentityXP = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref newIdentityXP);
				int newIdentityLevel = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref newIdentityLevel);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((LethalBotManager)(object)target).UpdateLethalBotsXPServerRpc(playerId, newIdentityXP, newIdentityLevel);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_4055705094(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int playerId = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref playerId);
				int newIdentityXP = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref newIdentityXP);
				int newIdentityLevel = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref newIdentityLevel);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((LethalBotManager)(object)target).UpdateLethalBotsXPClientRpc(playerId, newIdentityXP, newIdentityLevel);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3828485747(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: 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_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int numConnectedPlayers = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref numConnectedPlayers);
				int numLivingPlayers = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref numLivingPlayers);
				int numRealPlayers = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref numRealPlayers);
				ServerRpcParams server = rpcParams.Server;
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((LethalBotManager)(object)target).SendNewPlayerCountServerRpc(numConnectedPlayers, numLivingPlayers, numRealPlayers, server);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_765310706(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int numConnectedPlayers = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref numConnectedPlayers);
				int numLivingPlayers = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref numLivingPlayers);
				int numRealPlayers = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref numRealPlayers);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((LethalBotManager)(object)target).SendNewPlayerCountClientRpc(numConnectedPlayers, numLivingPlayers, numRealPlayers);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3244699581(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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_0050: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				ulong clientId = default(ulong);
				ByteUnpacker.ReadValueBitPacked(reader, ref clientId);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((LethalBotManager)(object)target).RequestPlayerCountServerRpc(clientId);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2483945957(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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_0050: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int numRealPlayers = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref numRealPlayers);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((LethalBotManager)(object)target).RequestPlayerCountClientRpc(numRealPlayers);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2917048395(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				bool hangarShipDoorStateServerRpc = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref hangarShipDoorStateServerRpc, default(ForPrimitives));
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((LethalBotManager)(object)target).SetHangarShipDoorStateServerRpc(hangarShipDoorStateServerRpc);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_611045299(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				bool hangarShipDoorStateClientRpc = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref hangarShipDoorStateClientRpc, default(ForPrimitives));
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((LethalBotManager)(object)target).SetHangarShipDoorStateClientRpc(hangarShipDoorStateClientRpc);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2655523674(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//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_007c: 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_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Invalid comparison between Unknown and I4
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if (rpcParams.Server.Receive.SenderClientId != target.OwnerClientId)
			{
				if ((int)networkManager.LogLevel <= 1)
				{
					Debug.LogError((object)"Only the owner can invoke a ServerRpc that requires ownership!");
				}
			}
			else
			{
				bool preRevive = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref preRevive, default(ForPrimitives));
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((LethalBotManager)(object)target).SyncEndOfRoundLethalBotsFromClientToServerRpc(preRevive);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3320735890(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				bool preRevive = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref preRevive, default(ForPrimitives));
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((LethalBotManager)(object)target).SyncEndOfRoundLethalBotsFromServerToClientRpc(preRevive);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_4292259290(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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_0050: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				ulong clientId = default(ulong);
				ByteUnpacker.ReadValueBitPacked(reader, ref clientId);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((LethalBotManager)(object)target).SyncLoadedJsonIdentitiesServerRpc(clientId);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3013741216(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((LethalBotManager)(object)target).SyncLoadedJsonIdentitiesToAllClientsServerRpc();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3548191887(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				ConfigIdentitiesNetworkSerializable configIdentityNetworkSerializable = default(ConfigIdentitiesNetworkSerializable);
				((FastBufferReader)(ref reader)).ReadValueSafe<ConfigIdentitiesNetworkSerializable>(ref configIdentityNetworkSerializable, default(ForNetworkSerializable));
				ClientRpcParams client = rpcParams.Client;
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((LethalBotManager)(object)target).SyncLoadedJsonIdentitiesClientRpc(configIdentityNetworkSerializable, client);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_700114798(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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_0050: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				ulong clientId = default(ulong);
				ByteUnpacker.ReadValueBitPacked(reader, ref clientId);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((LethalBotManager)(object)target).SyncLoadedJsonLoadoutsServerRpc(clientId);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2288718840(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				ConfigLoadoutsNetworkSerializable configLoadoutNetworkSerializable = default(ConfigLoadoutsNetworkSerializable);
				((FastBufferReader)(ref reader)).ReadValueSafe<ConfigLoadoutsNetworkSerializable>(ref configLoadoutNetworkSerializable, default(ForNetworkSerializable));
				ClientRpcParams client = rpcParams.Client;
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((LethalBotManager)(object)target).SyncLoadedJsonLoadoutsClientRpc(configLoadoutNetworkSerializable, client);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2651922194(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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_0050: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				ulong clientId = default(ulong);
				ByteUnpacker.ReadValueBitPacked(reader, ref clientId);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((LethalBotManager)(object)target).SyncLoadedJsonStockRequirementsServerRpc(clientId);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1309261795(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				ConfigStockRequirementNetworkSerializable configLoadoutNetworkSerializable = default(ConfigStockRequirementNetworkSerializable);
				((FastBufferReader)(ref reader)).ReadValueSafe<ConfigStockRequirementNetworkSerializable>(ref configLoadoutNetworkSerializable, default(ForNetworkSerializable));
				ClientRpcParams client = rpcParams.Client;
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((LethalBotManager)(object)target).SyncLoadedJsonStockRequirementsClientRpc(configLoadoutNetworkSerializable, client);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3788476863(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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_0050: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				ulong clientId = default(ulong);
				ByteUnpacker.ReadValueBitPacked(reader, ref clientId);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((LethalBotManager)(object)target).SyncLethalBotsToJoiningPlayerServerRpc(clientId);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3373517389(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: 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_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				bool flag = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
				SpawnLethalBotParamsNetworkSerializable[] spawnLethalBotParamsNetworkSerializable = null;
				if (flag)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe<SpawnLethalBotParamsNetworkSerializable>(ref spawnLethalBotParamsNetworkSerializable, default(ForNetworkSerializable));
				}
				ClientRpcParams client = rpcParams.Client;
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((LethalBotManager)(object)target).SyncLethalBotsToJoiningPlayerClientRpc(spawnLethalBotParamsNetworkSerializable, client);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2106849743(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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_0050: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int id = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref id);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((LethalBotManager)(object)target).UpdateReviveCountServerRpc(id);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1502255224(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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_0050: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int id = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref id);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((LethalBotManager)(object)target).UpdateReviveCountClientRpc(id);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_774372827(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int newGroupCredits = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref newGroupCredits);
				int numItemsInShip = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref numItemsInShip);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((LethalBotManager)(object)target).SyncGroupCreditsForNotOwnerTerminalServerRpc(newGroupCredits, numItemsInShip);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1208558443(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				bool flag = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
				string identityName = null;
				if (flag)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe(ref identityName, false);
				}
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((LethalBotManager)(object)target).UpdateReviveCompanyRemainingRevivesServerRpc(identityName);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_4031719329(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				bool flag = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
				string identityName = null;
				if (flag)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe(ref identityName, false);
				}
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((LethalBotManager)(object)target).UpdateReviveCompanyRemainingRevivesClientRpc(identityName);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3312171593(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((LethalBotManager)(object)target).SetStartingRevivesReviveCompanyServerRpc();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_965672077(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((LethalBotManager)(object)target).SetStartingRevivesReviveCompanyClientRpc();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_306000109(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				NetworkBehaviourReference missionControllerServerRpc = default(NetworkBehaviourReference);
				((FastBufferReader)(ref reader)).ReadValueSafe<NetworkBehaviourReference>(ref missionControllerServerRpc, default(ForNetworkSerializable));
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((LethalBotManager)(object)target).SetMissionControllerServerRpc(missionControllerServerRpc);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1022940860(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				NetworkBehaviourReference playerToAdd = default(NetworkBehaviourReference);
				((FastBufferReader)(ref reader)).ReadValueSafe<NetworkBehaviourReference>(ref playerToAdd, default(ForNetworkSerializable));
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((LethalBotManager)(object)target).AddPlayerToLootTransferListServerRpc(playerToAdd);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3935232259(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				NetworkBehaviourReference playerToRemove = default(NetworkBehaviourReference);
				((FastBufferReader)(ref reader)).ReadValueSafe<NetworkBehaviourReference>(ref playerToRemove, default(ForNetworkSerializable));
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((LethalBotManager)(object)target).RemovePlayerFromLootTransferListServerRpc(playerToRemove);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_4064771903(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				DayMode lastReportedTimeOfDayServerRpc = default(DayMode);
				((FastBufferReader)(ref reader)).ReadValueSafe<DayMode>(ref lastReportedTimeOfDayServerRpc, default(ForEnums));
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((LethalBotManager)(object)target).SetLastReportedTimeOfDayServerRpc(lastReportedTimeOfDayServerRpc);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1248913442(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				DayMode lastReportedTimeOfDayClientRpc = default(DayMode);
				((FastBufferReader)(ref reader)).ReadValueSafe<DayMode>(ref lastReportedTimeOfDayClientRpc, default(ForEnums));
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((LethalBotManager)(object)target).SetLastReportedTimeOfDayClientRpc(lastReportedTimeOfDayClientRpc);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		protected internal override string __getTypeName()
		{
			return "LethalBotManager";
		}
	}
	public class TimedOrderedLethalBotDistanceListCheck
	{
		private List<LethalBotAI> orderedLethalBotDistanceList;

		private long timer = 2000000L;

		private long lastTimeCalculate;

		public List<LethalBotAI> GetOrderedLethalBotDistanceList(LethalBotAI[] lethalBotAIs)
		{
			if (orderedLethalBotDistanceList == null)
			{
				orderedLethalBotDistanceList = new List<LethalBotAI>();
			}
			if (!NeedToRecalculate())
			{
				return orderedLethalBotDistanceList;
			}
			CalculateOrderedlethalBotDistanceList(lethalBotAIs);
			return orderedLethalBotDistanceList;
		}

		private bool NeedToRecalculate()
		{
			long num = DateTime.Now.Ticks - lastTimeCalculate;
			if (num > timer)
			{
				lastTimeCalculate = DateTime.Now.Ticks;
				return true;
			}
			return false;
		}

		private void CalculateOrderedlethalBotDistanceList(LethalBotAI[] lethalBotAIs)
		{
			orderedLethalBotDistanceList.Clear();
			foreach (LethalBotAI lethalBotAI in lethalBotAIs)
			{
				if (!((Object)(object)lethalBotAI == (Object)null) && !((EnemyAI)lethalBotAI).isEnemyDead && lethalBotAI.NpcController != null && lethalBotAI.NpcController.Npc.isPlayerControlled && !lethalBotAI.NpcController.Npc.isPlayerDead)
				{
					orderedLethalBotDistanceList.Add(lethalBotAI);
				}
			}
			orderedLethalBotDistanceList = orderedLethalBotDistanceList.OrderBy((LethalBotAI x) => x.NpcController.SqrDistanceWithLocalPlayerTimedCheck.GetSqrDistanceWithLocalPlayer(((Component)x.NpcController.Npc).transform.position)).ToList();
		}
	}
	public class LoadoutManager : MonoBehaviour
	{
		public LethalBotLoadout[] LethalBotLoadouts;

		private ConfigLoadout[] configLoadouts;

		public static LoadoutManager Instance { get; private set; }

		public LethalBotLoadout this[int index]
		{
			get
			{
				if (index < 0 || index >= LethalBotLoadouts.Length)
				{
					throw new IndexOutOfRangeException();
				}
				return LethalBotLoadouts[index];
			}
		}

		private void Awake()
		{
			if ((Object)(object)Instance != (Object)null && (Object)(object)Instance != (Object)(object)this)
			{
				Object.Destroy((Object)(object)((Component)Instance).gameObject);
			}
			Instance = this;
			Plugin.LogDebug("=============== awake LoadoutManager =====================");
		}

		public void InitLoadouts(ConfigLoadout[] configLoadouts)
		{
			Plugin.LogDebug($"InitLoadouts, nbLoadouts {configLoadouts.Length}");
			LethalBotLoadouts = new LethalBotLoadout[configLoadouts.Length];
			this.configLoadouts = configLoadouts;
			for (int i = 0; i < configLoadouts.Length; i++)
			{
				LethalBotLoadouts[i] = InitNewLoadout(i);
			}
		}

		private LethalBotLoadout InitNewLoadout(int idLoadout)
		{
			ConfigLoadout configLoadout;
			string name;
			if (idLoadout >= configLoadouts.Length)
			{
				configLoadout = ConfigConst.DEFAULT_CONFIG_LOADOUT;
				name = string.Format(configLoadout.name, idLoadout);
			}
			else
			{
				configLoadout = configLoadouts[idLoadout];
				name = configLoadout.name;
			}
			List<string> list = configLoadout.itemNames.ToList();
			List<Item> list2 = new List<Item>();
			foreach (Item items in StartOfRound.Instance.allItemsList.itemsList)
			{
				if ((Object)(object)items != (Object)null && !list2.Contains(items) && list.Contains(items.itemName))
				{
					list2.Add(items);
					list.Remove(items.itemName);
					if (list.Count == 0)
					{
						break;
					}
				}
			}
			return new LethalBotLoadout(idLoadout, name, list2.ToArray());
		}

		public LethalBotLoadout GetLethalBotLoadoutWithName(string name)
		{
			name = name.Trim().ToLower();
			LethalBotLoadout[] lethalBotLoadouts = LethalBotLoadouts;
			foreach (LethalBotLoadout lethalBotLoadout in lethalBotLoadouts)
			{
				string text = lethalBotLoadout.Name.Trim().ToLower();
				if (text == name)
				{
					return lethalBotLoadout;
				}
			}
			if (name != "empty")
			{
				Plugin.LogWarning("LoadoutManager failed to find loadout with name " + name + "! Using default: Empty!");
				return GetLethalBotLoadoutWithName("Empty");
			}
			int num = LethalBotLoadouts.Length;
			Array.Resize(ref LethalBotLoadouts, num + 1);
			Plugin.LogInfo("LoadoutManager creating default loadout!");
			ConfigLoadout dEFAULT_CONFIG_LOADOUT = ConfigConst.DEFAULT_CONFIG_LOADOUT;
			string name2 = dEFAULT_CONFIG_LOADOUT.name;
			Item[] items = (Item[])(object)new Item[0];
			LethalBotLoadout lethalBotLoadout2 = new LethalBotLoadout(-1, name2, items);
			LethalBotLoadouts[num] = lethalBotLoadout2;
			return lethalBotLoadout2;
		}

		public LethalBotLoadout? GetLoadoutFromIndex(int index)
		{
			if (index < 0 || index > LethalBotLoadouts.Length)
			{
				return null;
			}
			return LethalBotLoadouts[index];
		}
	}
	public class PluginManager : MonoBehaviour
	{
		public GameObject SaveManagerPrefab;

		public GameObject LethalBotManagerPrefab;

		public GameObject TerminalManagerPrefab;

		public GameObject GroupManagerPrefab;

		public static PluginManager Instance { get; private set; }

		private void Awake()
		{
			if ((Object)(object)Instance != (Object)null && (Object)(object)Instance != (Object)(object)this)
			{
				Object.Destroy((Object)(object)((Component)Instance).gameObject);
			}
			Instance = this;
			Object.DontDestroyOnLoad((Object)(object)((Component)this).gameObject);
		}

		public void InitManagers()
		{
			LethalBotManagerPrefab = NetworkPrefabs.CreateNetworkPrefab("LethalBotManager");
			LethalBotManagerPrefab.AddComponent<LethalBotManager>();
			SaveManagerPrefab = NetworkPrefabs.CreateNetworkPrefab("SaveManager");
			SaveManagerPrefab.AddComponent<SaveManager>();
			TerminalManagerPrefab = NetworkPrefabs.CreateNetworkPrefab("TerminalManager");
			TerminalManagerPrefab.AddComponent<TerminalManager>();
			GroupManagerPrefab = NetworkPrefabs.CreateNetworkPrefab("GroupManager");
			GroupManagerPrefab.AddComponent<GroupManager>();
		}
	}
	public class RestockManager : MonoBehaviour
	{
		public LethalBotStockRequirement[] LethalBotStockRequirements;

		private ConfigStockRequirement[] configStockRequirements;

		public static RestockManager Instance { get; private set; }

		public LethalBotStockRequirement this[int index]
		{
			get
			{
				if (index < 0 || index >= LethalBotStockRequirements.Length)
				{
					throw new IndexOutOfRangeException();
				}
				return LethalBotStockRequirements[index];
			}
		}

		private void Awake()
		{
			if ((Object)(object)Instance != (Object)null && (Object)(object)Instance != (Object)(object)this)
			{
				Object.Destroy((Object)(object)((Component)Instance).gameObject);
			}
			Instance = this;
			Plugin.LogDebug("=============== awake RestockManager =====================");
		}

		public void InitStockRequirements(ConfigStockRequirement[] configStockRequirements)
		{
			Plugin.LogDebug($"InitStockRequirements, nbStockRequirements {configStockRequirements.Length}");
			LethalBotStockRequirements = new LethalBotStockRequirement[configStockRequirements.Length];
			this.configStockRequirements = configStockRequirements;
			for (int i = 0; i < configStockRequirements.Length; i++)
			{
				LethalBotStockRequirements[i] = InitNewStockRequirement(i);
			}
		}

		private LethalBotStockRequirement InitNewStockRequirement(int idStockRequirement)
		{
			ConfigStockRequirement configStockRequirement = ((idStockRequirement < configStockRequirements.Length) ? configStockRequirements[idStockRequirement] : ConfigConst.DEFAULT_CONFIG_STOCK_REQUIREMENT);
			Dictionary<string, Item> dictionary = new Dictionary<string, Item>();
			foreach (Item items in StartOfRound.Instance.allItemsList.itemsList)
			{
				if (!((Object)(object)items == (Object)null))
				{
					if (!dictionary.ContainsKey(items.itemName))
					{
						dictionary[items.itemName] = items;
					}
					else
					{
						Plugin.LogWarning("Duplicate item name detected: " + items.itemName);
					}
				}
			}
			string itemName = configStockRequirement.itemName;
			Plugin.LogInfo("RestockManager attempting to register stock requirement for item " + itemName);
			if (!dictionary.TryGetValue(itemName, out var value))
			{
				value = null;
			}
			List<LethalBotStockRequiredItem> list = new List<LethalBotStockRequiredItem>();
			if (configStockRequirement.requiredItems != null)
			{
				ConfigStockRequiredItem[] requiredItems = configStockRequirement.requiredItems;
				for (int i = 0; i < requiredItems.Length; i++)
				{
					ConfigStockRequiredItem configStockRequiredItem = requiredItems[i];
					string itemName2 = configStockRequiredItem.itemName;
					if (dictionary.TryGetValue(itemName2, out var value2))
					{
						list.Add(new LethalBotStockRequiredItem(value2, configStockRequiredItem.requiredStock));
					}
					else
					{
						Plugin.LogWarning("Failed to find required item with name " + itemName2 + "! Is the name misspelled or has the wrong letter case?");
					}
				}
			}
			if (!string.IsNullOrWhiteSpace(configStockRequirement.requiredItemName))
			{
				string requiredItemName = configStockRequirement.requiredItemName;
				if (dictionary.TryGetValue(requiredItemName, out var value3))
				{
					list.Add(new LethalBotStockRequiredItem(value3, 1));
				}
				else
				{
					Plugin.LogWarning("Failed to find required item with name " + requiredItemName + "! Is the name misspelled or has the wrong letter case?");
				}
			}
			bool overrideEcoLimit = configStockRequirement.overrideEcoLimit;
			int ecoLimit = configStockRequirement.ecoLimit;
			if ((Object)(object)value == (Object)null)
			{
				Plugin.LogWarning("Failed to find item with name " + itemName + "! Is the name misspelled or has the wrong letter case?");
				return new LethalBotStockRequirement(idStockRequirement, null, 0, overrideEcoLimit, ecoLimit, list);
			}
			Plugin.LogInfo("RestockManager successfully registered stock requirement for item " + itemName);
			return new LethalBotStockRequirement(idStockRequirement, value, configStockRequirement.desiredStock, overrideEcoLimit, ecoLimit, list);
		}

		public LethalBotStockRequirement? GetLethalBotStockRequirementWithName(string name)
		{
			name = name.Trim().ToLower();
			LethalBotStockRequirement[] lethalBotStockRequirements = LethalBotStockRequirements;
			foreach (LethalBotStockRequirement lethalBotStockRequirement in lethalBotStockRequirements)
			{
				if (lethalBotStockRequirement != null && (Object)(object)lethalBotStockRequirement.Item != (Object)null)
				{
					string text = lethalBotStockRequirement.Name.Trim().ToLower();
					if (text == name)
					{
						return lethalBotStockRequirement;
					}
				}
			}
			return null;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public LethalBotStockRequirement? GetLethalBotStockRequirementWithItem(Item item)
		{
			if (!((Object)(object)item != (Object)null))
			{
				return null;
			}
			return GetLethalBotStockRequirementWithName(item.itemName);
		}

		public LethalBotStockRequirement? GetStockRequirementFromIndex(int index)
		{
			if (index < 0 || index > LethalBotStockRequirements.Length)
			{
				return null;
			}
			return LethalBotStockRequirements[index];
		}
	}
	public class SaveManager : NetworkBehaviour
	{
		private const string SAVE_DATA_KEY = "LETHAL_BOTS_SAVE_DATA";

		private ClientRpcParams ClientRpcParams;

		public static SaveManager Instance { get; private set; }

		public SaveFile Save { get; private set; }

		private void Awake()
		{
			if ((Object)(object)Instance != (Object)null && (Object)(object)Instance != (Object)(object)this)
			{
				if (((NetworkBehaviour)Instance).IsSpawned && ((NetworkBehaviour)Instance).IsServer)
				{
					((NetworkBehaviour)Instance).NetworkObject.Despawn(true);
				}
				else
				{
					Object.Destroy((Object)(object)((Component)Instance).gameObject);
				}
			}
			Instance = this;
			FetchSaveFile();
		}

		public override void OnNetworkSpawn()
		{
			((NetworkBehaviour)this).OnNetworkSpawn();
			if (!((NetworkBehaviour)this).NetworkManager.IsServer)
			{
				if ((Object)(object)Instance != (Object)null && (Object)(object)Instance != (Object)(object)this)
				{
					Object.Destroy((Object)(object)((Component)Instance).gameObject);
				}
				Instance = this;
			}
		}

		private void FetchSaveFile()
		{
			string currentSaveFileName = GameNetworkManager.Instance.currentSaveFileName;
			try
			{
				string text = (string)ES3.Load("LETHAL_BOTS_SAVE_DATA", currentSaveFileName, (object)null);
				if (text != null)
				{
					Plugin.LogInfo("Loading save file.");
					Save = JsonConvert.DeserializeObject<SaveFile>(text) ?? new SaveFile();
					if (Plugin.Config.ResetIdentities.Value)
					{
						Plugin.Config.ResetIdentities.Value = false;
						Save.IdentitiesSaveFiles = new IdentitySaveFile[0];
					}
					else if (SyncedEntry<bool>.op_Implicit(Plugin.Config.SpawnIdentitiesRandomly))
					{
						Plugin.LogInfo("Plugin config set to spawn identities randomly, setting all identities to available in save file.");
						IdentitySaveFile[] identitiesSaveFiles = Save.IdentitiesSaveFiles;
						foreach (IdentitySaveFile identitySaveFile in identitiesSaveFiles)
						{
							identitySaveFile.Status = 0;
						}
					}
				}
				else
				{
					Plugin.LogInfo("No save file found for slot. Creating new.");
					Save = new SaveFile();
				}
			}
			catch (Exception ex)
			{
				Plugin.LogError("Error when loading save file : " + ex.Message);
			}
		}

		public void SavePluginInfos()
		{
			if (((NetworkBehaviour)this).NetworkManager.IsHost && StartOfRound.Instance.inShipPhase && !StartOfRound.Instance.isChallengeFile)
			{
				Plugin.LogInfo("Saving data for LethalBot plugin.");
				string currentSaveFileName = GameNetworkManager.Instance.currentSaveFileName;
				SaveInfosInSave();
				string text = JsonConvert.SerializeObject((object)Save);
				ES3.Save<string>("LETHAL_BOTS_SAVE_DATA", text, currentSaveFileName);
			}
		}

		private void SaveInfosInSave()
		{
			//IL_0154: Unknown result type (might be due to invalid IL or missing references)
			//IL_0159: Unknown result type (might be due to invalid IL or missing references)
			Save.IdentitiesSaveFiles = new IdentitySaveFile[IdentityManager.Instance.LethalBotIdentities.Length];
			for (int i = 0; i < IdentityManager.Instance.LethalBotIdentities.Length; i++)
			{
				LethalBotIdentity lethalBotIdentity = IdentityManager.Instance.LethalBotIdentities[i];
				int num = ((i < Plugin.Config.ConfigIdentities.configIdentities.Length) ? Plugin.Config.ConfigIdentities.configIdentities[i].suitID : (-1));
				if (num != -1 && Plugin.Config.ConfigIdentities.configIdentities[i].suitConfigOption == 1)
				{
					num = -1;
				}
				EnumStatusIdentity status = lethalBotIdentity.Status;
				IdentitySaveFile identitySaveFile = new IdentitySaveFile
				{
					IdIdentity = lethalBotIdentity.IdIdentity,
					Hp = lethalBotIdentity.Hp,
					SuitID = ((num < 0) ? (-1) : num),
					XP = lethalBotIdentity.XP.GetValueOrDefault(-1),
					Level = ((lethalBotIdentity.Level >= 0) ? lethalBotIdentity.Level : 0),
					Status = (int)((lethalBotIdentity.Status == EnumStatusIdentity.Spawned) ? EnumStatusIdentity.ToSpawn : lethalBotIdentity.Status)
				};
				Plugin.LogDebug("Saving identity " + lethalBotIdentity.ToString());
				Save.IdentitiesSaveFiles[i] = identitySaveFile;
			}
			List<LethalBotBlacklistedItem> list = new List<LethalBotBlacklistedItem>();
			NetworkObject val2 = default(NetworkObject);
			for (int j = 0; j < LethalBotManager.Instance.blacklistedItems.Count; j++)
			{
				NetworkObjectReference val = LethalBotManager.Instance.blacklistedNetworkList[j];
				if (!((NetworkObjectReference)(ref val)).TryGet(ref val2, (NetworkManager)null))
				{
					Plugin.LogError($"SaveManager.SaveInfosInSave: Failed to resolve NetworkObjectReference at index {j} (likely despawned).");
					continue;
				}
				GrabbableObject component = ((Component)val2).gameObject.GetComponent<GrabbableObject>();
				if ((Object)(object)component == (Object)null)
				{
					Plugin.LogError($"SaveManager.SaveInfosInSave: Failed to resolve GrabbableObject component from network object at index {j}");
					continue;
				}
				LethalBotBlacklistedItem lethalBotBlacklistedItem = new LethalBotBlacklistedItem(component);
				list.Add(lethalBotBlacklistedItem);
				Plugin.LogDebug($"Saving blacklisted item {lethalBotBlacklistedItem}");
			}
			Save.BlacklistedItems = list.ToArray();
		}

		public void LoadAllDataFromSave()
		{
			if (Save.IdentitiesSaveFiles == null)
			{
				return;
			}
			if (Save.IdentitiesSaveFiles.Length > IdentityManager.Instance.LethalBotIdentities.Length)
			{
				IdentityManager.Instance.ExpandWithNewDefaultIdentities(Save.IdentitiesSaveFiles.Length - IdentityManager.Instance.LethalBotIdentities.Length);
			}
			for (int i = 0; i < IdentityManager.Instance.LethalBotIdentities.Length; i++)
			{
				LethalBotIdentity lethalBotIdentity = IdentityManager.Instance.LethalBotIdentities[i];
				if (lethalBotIdentity.IdIdentity < Save.IdentitiesSaveFiles.Length)
				{
					IdentitySaveFile identitySaveFile = Save.IdentitiesSaveFiles[lethalBotIdentity.IdIdentity];
					lethalBotIdentity.UpdateIdentity(identitySaveFile.Hp, (identitySaveFile.SuitID < 0) ? null : new int?(identitySaveFile.SuitID), (identitySaveFile.XP < 0) ? null : new int?(identitySaveFile.XP), (identitySaveFile.Level >= 0) ? identitySaveFile.Level : 0, (EnumStatusIdentity)identitySaveFile.Status);
					Plugin.LogDebug("Loaded and updated identity from save : " + lethalBotIdentity.ToString());
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void SyncCurrentValuesServerRpc(ulong clientId)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_0117: Unknown result type (might be due to invalid IL or missing references)
			//IL_0118: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f1: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				ServerRpcParams val = default(ServerRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(1164667008u, val, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val2, clientId);
				((NetworkBehaviour)this).__endSendServerRpc(ref val2, 1164667008u, val, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				Plugin.LogDebug($"Client {clientId} ask server/host {((NetworkBehaviour)this).NetworkManager.LocalClientId} to SyncCurrentStateValuesServerRpc");
				ClientRpcParams.Send = new ClientRpcSendParams
				{
					TargetClientIds = new ulong[1] { clientId }
				};
				IdentitySaveFileNetworkSerializable[] array = new IdentitySaveFileNetworkSerializable[IdentityManager.Instance.LethalBotIdentities.Length];
				for (int i = 0; i < array.Length; i++)
				{
					LethalBotIdentity lethalBotIdentity = IdentityManager.Instance.LethalBotIdentities[i];
					IdentitySaveFileNetworkSerializable identitySaveFileNetworkSerializable = default(IdentitySaveFileNetworkSerializable);
					identitySaveFileNetworkSerializable.IdIdentity = lethalBotIdentity.IdIdentity;
					identitySaveFileNetworkSerializable.Hp = lethalBotIdentity.Hp;
					identitySaveFileNetworkSerializable.SuitID = lethalBotIdentity.SuitID.GetValueOrDefault(-1);
					identitySaveFileNetworkSerializable.XP = lethalBotIdentity.XP.GetValueOrDefault(-1);
					identitySaveFileNetworkSerializable.Level = ((lethalBotIdentity.Level >= 0) ? lethalBotIdentity.Level : 0);
					identitySaveFileNetworkSerializable.Status = (int)lethalBotIdentity.Status;
					IdentitySaveFileNetworkSerializable identitySaveFileNetworkSerializable2 = identitySaveFileNetworkSerializable;
					array[i] = identitySaveFileNetworkSerializable2;
				}
				SaveNetworkSerializable saveNetworkSerializable = default(SaveNetworkSerializable);
				saveNetworkSerializable.Identities = array;
				SaveNetworkSerializable saveNetworkSerializable2 = saveNetworkSerializable;
				SyncCurrentValuesClientRpc(saveNetworkSerializable2, ClientRpcParams);
			}
		}

		[ClientRpc]
		private void SyncCurrentValuesClientRpc(SaveNetworkSerializable saveNetworkSerializable, ClientRpcParams clientRpcParams = default(ClientRpcParams))
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(4180451471u, clientRpcParams, (RpcDelivery)0);
				((FastBufferWriter)(ref val)).WriteValueSafe<SaveNetworkSerializable>(ref saveNetworkSerializable, default(ForNetworkSerializable));
				((NetworkBehaviour)this).__endSendClientRpc(ref val, 4180451471u, clientRpcParams, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage != 1 || (!networkManager.IsClient && !networkManager.IsHost))
			{
				return;
			}
			base.__rpc_exec_stage = (__RpcExecStage)0;
			if (((NetworkBehaviour)this).IsOwner)
			{
				return;
			}
			if (saveNetworkSerializable.Identities.Length > IdentityManager.Instance.LethalBotIdentities.Length)
			{
				IdentityManager.Instance.ExpandWithNewDefaultIdentities(saveNetworkSerializable.Identities.Length - IdentityManager.Instance.LethalBotIdentities.Length);
			}
			for (int i = 0; i < IdentityManager.Instance.LethalBotIdentities.Length; i++)
			{
				LethalBotIdentity lethalBotIdentity = IdentityManager.Instance.LethalBotIdentities[i];
				if (lethalBotIdentity.IdIdentity >= saveNetworkSerializable.Identities.Length)
				{
					break;
				}
				IdentitySaveFileNetworkSerializable identitySaveFileNetworkSerializable = saveNetworkSerializable.Identities[i];
				lethalBotIdentity.UpdateIdentity(identitySaveFileNetworkSerializable.Hp, (identitySaveFileNetworkSerializable.SuitID < 0) ? null : new int?(identitySaveFileNetworkSerializable.SuitID), (identitySaveFileNetworkSerializable.XP < 0) ? null : new int?(identitySaveFileNetworkSerializable.XP), (identitySaveFileNetworkSerializable.Level >= 0) ? identitySaveFileNetworkSerializable.Level : 0, (EnumStatusIdentity)identitySaveFileNetworkSerializable.Status);
				Plugin.LogDebug($"Client {((NetworkBehaviour)this).NetworkManager.LocalClientId} : sync in current values, identity {lethalBotIdentity.ToString()}");
			}
		}

		protected override void __initializeVariables()
		{
			((NetworkBehaviour)this).__initializeVariables();
		}

		protected override void __initializeRpcs()
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Expected O, but got Unknown
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Expected O, but got Unknown
			((NetworkBehaviour)this).__registerRpc(1164667008u, new RpcReceiveHandler(__rpc_handler_1164667008), "SyncCurrentValuesServerRpc");
			((NetworkBehaviour)this).__registerRpc(4180451471u, new RpcReceiveHandler(__rpc_handler_4180451471), "SyncCurrentValuesClientRpc");
			((NetworkBehaviour)this).__initializeRpcs();
		}

		private static void __rpc_handler_1164667008(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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_0050: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				ulong clientId = default(ulong);
				ByteUnpacker.ReadValueBitPacked(reader, ref clientId);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((SaveManager)(object)target).SyncCurrentValuesServerRpc(clientId);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_4180451471(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				SaveNetworkSerializable saveNetworkSerializable = default(SaveNetworkSerializable);
				((FastBufferReader)(ref reader)).ReadValueSafe<SaveNetworkSerializable>(ref saveNetworkSerializable, default(ForNetworkSerializable));
				ClientRpcParams client = rpcParams.Client;
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((SaveManager)(object)target).SyncCurrentValuesClientRpc(saveNetworkSerializable, client);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		protected internal override string __getTypeName()
		{
			return "SaveManager";
		}
	}
	public static class SignalTranslatorCommandsManager
	{
		private static readonly List<SignalTranslatorCommand> globalCommands = new List<SignalTranslatorCommand>();

		private static readonly Dictionary<Type, List<SignalTranslatorCommand>> stateCommands = new Dictionary<Type, List<SignalTranslatorCommand>>();

		private static readonly HashSet<Type> ignoreGlobalCommands = new HashSet<Type>();

		public static void RegisterGlobalCommand(SignalTranslatorCommand command)
		{
			globalCommands.Add(command);
		}

		public static void RegisterIgnoreDefaultForState<T>() where T : AIState
		{
			ignoreGlobalCommands.Add(typeof(T));
		}

		public static void RegisterCommandForState<T>(SignalTranslatorCommand command) where T : AIState
		{
			Type typeFromHandle = typeof(T);
			if (!stateCommands.TryGetValue(typeFromHandle, out List<SignalTranslatorCommand> value))
			{
				value = new List<SignalTranslatorCommand>();
				stateCommands[typeFromHandle] = value;
			}
			value.Add(command);
		}

		internal static void RemoveAllSignalTranslatorCommands()
		{
			globalCommands.Clear();
			stateCommands.Clear();
			ignoreGlobalCommands.Clear();
		}

		public static bool OnSignalTranslatorMessageReceived(AIState state, string message)
		{
			Type type = state.GetType();
			LethalBotAI ai = state.ai;
			if (stateCommands.TryGetValue(type, out List<SignalTranslatorCommand> value))
			{
				foreach (SignalTranslatorCommand item in value)
				{
					if (message.Contains(item.Keyword) && item.Execute(state, ai, message))
					{
						return true;
					}
				}
			}
			if (ignoreGlobalCommands.Contains(type))
			{
				return false;
			}
			foreach (SignalTranslatorCommand globalCommand in globalCommands)
			{
				if (message.Contains(globalCommand.Keyword) && globalCommand.Execute(state, ai, message))
				{
					return true;
				}
			}
			return false;
		}
	}
	internal class TerminalManager : NetworkBehaviour
	{
		private Terminal? terminalScript;

		private static readonly MethodInfo loadNewNodeIfAffordableMethod = AccessTools.Method(typeof(Terminal), "LoadNewNodeIfAffordable", (Type[])null, (Type[])null);

		private static readonly MethodInfo attemptLoadCreatureFileNodeMethod = AccessTools.Method(typeof(Terminal), "AttemptLoadCreatureFileNode", (Type[])null, (Type[])null);

		private static readonly MethodInfo attemptLoadStoryLogFileNodeMethod = AccessTools.Method(typeof(Terminal), "AttemptLoadStoryLogFileNode", (Type[])null, (Type[])null);

		private static readonly MethodInfo parseWordOverrideOptionsMethod = AccessTools.Method(typeof(Terminal), "ParseWordOverrideOptions", (Type[])null, (Type[])null);

		private static readonly MethodInfo checkForPlayerNameCommandMethod = AccessTools.Method(typeof(Terminal), "CheckForPlayerNameCommand", (Type[])null, (Type[])null);

		private static readonly MethodInfo checkForExactSentencesMethod = AccessTools.Method(typeof(Terminal), "CheckForExactSentences", (Type[])null, (Type[])null);

		private static readonly MethodInfo callFunctionInAccessibleTerminalObjectMethod = AccessTools.Method(typeof(Terminal), "CallFunctionInAccessibleTerminalObject", (Type[])null, (Type[])null);

		private static readonly MethodInfo playBroadcastCodeEffectMethod = AccessTools.Method(typeof(Terminal), "PlayBroadcastCodeEffect", (Type[])null, (Type[])null);

		private static readonly MethodInfo parseWordMethod = AccessTools.Method(typeof(Terminal), "ParseWord", (Type[])null, (Type[])null);

		public static TerminalManager Instance { get; internal set; } = null;


		private void Awake()
		{
			if ((Object)(object)Instance != (Object)null && (Object)(object)Instance != (Object)(object)this)
			{
				if (((NetworkBehaviour)Instance).IsSpawned && ((NetworkBehaviour)Instance).IsServer)
				{
					((NetworkBehaviour)Instance).NetworkObject.Despawn(true);
				}
				else
				{
					Object.Destroy((Object)(object)((Component)Instance).gameObject);
				}
			}
			Instance = this;
		}

		public override void OnNetworkSpawn()
		{
			((NetworkBehaviour)this).OnNetworkSpawn();
			if (!((NetworkBehaviour)this).NetworkManager.IsServer)
			{
				if ((Object)(object)Instance != (Object)null && (Object)(object)Instance != (Object)(object)this)
				{
					Object.Destroy((Object)(object)((Component)Instance).gameObject);
				}
				Instance = this;
			}
		}

		public Terminal GetTerminal()
		{
			if ((Object)(object)terminalScript == (Object)null)
			{
				terminalScript = GameObject.Find("TerminalScript").GetComponent<Terminal>();
			}
			return terminalScript;
		}

		private static string RemovePunctuation(string s)
		{
			StringBuilder stringBuilder = new StringBuilder();
			foreach (char c in s)
			{
				if (!char.IsPunctuation(c))
				{
					stringBuilder.Append(c);
				}
			}
			return stringBuilder.ToString().ToLower();
		}

		public void OnSubmit(string text, Terminal? ourTerminal = null)
		{
			if (ourTerminal == null)
			{
				ourTerminal = GetTerminal();
			}
			if ((Object)(object)ourTerminal == (Object)null)
			{
				return;
			}
			if ((Object)(object)ourTerminal.currentNode != (Object)null && ourTerminal.currentNode.acceptAnything)
			{
				ourTerminal.LoadNewNode(ourTerminal.currentNode.terminalOptions[0].result);
				return;
			}
			TerminalNode val = ParsePlayerSentence(ourTerminal, text);
			if ((Object)(object)val != (Object)null)
			{
				ref int reference = ref PatchesUtil.totalCostOfItemsField.Invoke(ourTerminal);
				if (val.buyRerouteToMoon == -2)
				{
					reference = val.itemCost;
				}
				else if (val.itemCost != 0)
				{
					reference = val.itemCost * ourTerminal.playerDefinedAmount;
				}
				if (val.buyItemIndex != -1 || (val.buyRerouteToMoon != -1 && val.buyRerouteToMoon != -2) || val.shipUnlockableID != -1 || val.buyVehicleIndex != -1)
				{
					loadNewNodeIfAffordableMethod.Invoke(ourTerminal, new object[1] { val });
				}
				else if (val.creatureFileID != -1)
				{
					attemptLoadCreatureFileNodeMethod.Invoke(ourTerminal, new object[1] { val });
				}
				else if (val.storyLogFileID != -1)
				{
					attemptLoadStoryLogFileNodeMethod.Invoke(ourTerminal, new object[1] { val });
				}
				else
				{
					ourTerminal.LoadNewNode(val);
				}
			}
		}

		private TerminalNode? ParsePlayerSentence(Terminal ourTerminal, string text)
		{
			//IL_02e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ef: Expected O, but got Unknown
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Expected O, but got Unknown
			//IL_03c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_03cc: Expected O, but got Unknown
			ref bool reference = ref PatchesUtil.broadcastedCodeThisFrameField.Invoke(ourTerminal);
			ref bool reference2 = ref PatchesUtil.hasGottenNounField.Invoke(ourTerminal);
			ref bool reference3 = ref PatchesUtil.hasGottenVerbField.Invoke(ourTerminal);
			reference = false;
			string text2 = RemovePunctuation(text);
			string[] array = text2.Split(" ", StringSplitOptions.RemoveEmptyEntries);
			TerminalKeyword val = null;
			if ((Object)(object)ourTerminal.currentNode != (Object)null && ourTerminal.currentNode.overrideOptions)
			{
				for (int i = 0; i < array.Length; i++)
				{
					TerminalNode val2 = (TerminalNode)parseWordOverrideOptionsMethod.Invoke(ourTerminal, new object[2]
					{
						array[i],
						ourTerminal.currentNode.terminalOptions
					});
					if ((Object)(object)val2 != (Object)null)
					{
						return val2;
					}
				}
				return null;
			}
			if (array.Length > 1)
			{
				switch (array[0])
				{
				case "switch":
				{
					int num3 = (int)checkForPlayerNameCommandMethod.Invoke(ourTerminal, new object[2]
					{
						array[0],
						array[1]
					});
					if (num3 != -1)
					{
						StartOfRound.Instance.mapScreen.SwitchRadarTargetAndSync(num3);
						return ourTerminal.terminalNodes.specialNodes[20];
					}
					break;
				}
				case "flash":
				{
					int num2 = (int)checkForPlayerNameCommandMethod.Invoke(ourTerminal, new object[2]
					{
						array[0],
						array[1]
					});
					if (num2 != -1)
					{
						StartOfRound.Instance.mapScreen.FlashRadarBooster(num2);
						return ourTerminal.terminalNodes.specialNodes[23];
					}
					if (StartOfRound.Instance.mapScreen.radarTargets[StartOfRound.Instance.mapScreen.targetTransformIndex].isNonPlayer)
					{
						StartOfRound.Instance.mapScreen.FlashRadarBooster(StartOfRound.Instance.mapScreen.targetTransformIndex);
						return ourTerminal.terminalNodes.specialNodes[23];
					}
					break;
				}
				case "ping":
				{
					int num = (int)checkForPlayerNameCommandMethod.Invoke(ourTerminal, new object[2]
					{
						array[0],
						array[1]
					});
					if (num != -1)
					{
						StartOfRound.Instance.mapScreen.PingRadarBooster(num);
						return ourTerminal.terminalNodes.specialNodes[21];
					}
					break;
				}
				case "transmit":
				{
					SignalTranslator signalTranslator = MissionControlState.SignalTranslator;
					if ((Object)(object)signalTranslator == (Object)null || !(Time.realtimeSinceStartup - signalTranslator.timeLastUsingSignalTranslator > 8f) || array.Length < 2)
					{
						break;
					}
					string text3 = text2.Substring(8);
					if (!string.IsNullOrEmpty(text3))
					{
						if (!((NetworkBehaviour)ourTerminal).IsServer)
						{
							signalTranslator.timeLastUsingSignalTranslator = Time.realtimeSinceStartup;
						}
						HUDManager.Instance.UseSignalTranslatorServerRpc(text3.Substring(0, Mathf.Min(text3.Length, 10)));
						return ourTerminal.terminalNodes.specialNodes[22];
					}
					break;
				}
				}
			}
			val = (TerminalKeyword)checkForExactSentencesMethod.Invoke(ourTerminal, new object[1] { text2 });
			if ((Object)(object)val != (Object)null)
			{
				if (val.accessTerminalObjects)
				{
					callFunctionInAccessibleTerminalObjectMethod.Invoke(ourTerminal, new object[1] { val.word });
					playBroadcastCodeEffectMethod.Invoke(ourTerminal, null);
					return null;
				}
				if ((Object)(object)val.specialKeywordResult != (Object)null)
				{
					return val.specialKeywordResult;
				}
			}
			string value = Regex.Match(text2, "\\d+").Value;
			if (!string.IsNullOrWhiteSpace(value))
			{
				ourTerminal.playerDefinedAmount = Mathf.Clamp(int.Parse(value), 0, 10);
			}
			else
			{
				ourTerminal.playerDefinedAmount = 1;
			}
			if (array.Length > 5)
			{
				return null;
			}
			TerminalKeyword val3 = null;
			TerminalKeyword val4 = null;
			new List<TerminalKeyword>();
			bool flag = false;
			reference2 = false;
			reference3 = false;
			for (int j = 0; j < array.Length; j++)
			{
				val = (TerminalKeyword)parseWordMethod.Invoke(ourTerminal, new object[2]
				{
					array[j],
					2
				});
				if ((Object)(object)val != (Object)null)
				{
					Plugin.LogInfo("Parsed word: " + array[j]);
					if (val.isVerb)
					{
						if (reference3)
						{
							continue;
						}
						reference3 = true;
						val3 = val;
					}
					else
					{
						if (reference2)
						{
							continue;
						}
						reference2 = true;
						val4 = val;
						if (val.accessTerminalObjects)
						{
							reference = true;
							callFunctionInAccessibleTerminalObjectMethod.Invoke(ourTerminal, new object[1] { val.word });
							flag = true;
						}
					}
					if (!flag & reference2 & reference3)
					{
						break;
					}
				}
				else
				{
					Plugin.LogInfo("Could not parse word: " + array[j]);
				}
			}
			if (reference)
			{
				playBroadcastCodeEffectMethod.Invoke(ourTerminal, null);
				return ourTerminal.terminalNodes.specialNodes[19];
			}
			reference2 = false;
			reference3 = false;
			if ((Object)(object)val4 == (Object)null)
			{
				return ourTerminal.terminalNodes.specialNodes[10];
			}
			if ((Object)(object)val3 == (Object)null)
			{
				if ((Object)(object)val4.defaultVerb == (Object)null)
				{
					return ourTerminal.terminalNodes.specialNodes[11];
				}
				val3 = val4.defaultVerb;
			}
			for (int k = 0; k < val3.compatibleNouns.Length; k++)
			{
				if ((Object)(object)val3.compatibleNouns[k].noun == (Object)(object)val4)
				{
					Plugin.LogInfo($"noun keyword: {val4.word} ; verb keyword: {val3.word} ; result null? : {(Object)(object)val3.compatibleNouns[k].result == (Object)null}");
					Plugin.LogInfo("result: " + ((Object)val3.compatibleNouns[k].result).name);
					return val3.compatibleNouns[k].result;
				}
			}
			return ourTerminal.terminalNodes.specialNodes[12];
		}

		protected override void __initializeVariables()
		{
			((NetworkBehaviour)this).__initializeVariables();
		}

		protected override void __initializeRpcs()
		{
			((NetworkBehaviour)this).__initializeRpcs();
		}

		protected internal override string __getTypeName()
		{
			return "TerminalManager";
		}
	}
}
namespace LethalBots.Inputs
{
	public class LethalBotsInputs : LcInputActions
	{
		[InputAction(/*Could not decode attribute arguments.*/)]
		public InputAction LeadBot { get; set; }

		[InputAction(/*Could not decode attribute arguments.*/)]
		public InputAction DropItem { get; set; }

		[InputAction(/*Could not decode attribute arguments.*/)]
		public InputAction ChangeSuitBot { get; set; }

		[InputAction(/*Could not decode attribute arguments.*/)]
		public InputAction MakeBotLookAtPosition { get; set; }
	}
}
namespace LethalBots.Enums
{
	public enum EnumAIStates
	{
		BrainDead,
		SearchingForPlayer,
		GetCloseToPlayer,
		JustLostPlayer,
		ChillWithPlayer,
		FetchingObject,
		PlayerInCruiser,
		Panik,
		ReturnToShip,
		ChillAtShip,
		SearchingForScrap,
		UseInverseTeleport,
		UseKeyOnLockedDoor,
		MissionControl,
		SellScrap,
		CollectScrapToSell,
		FightEnemy,
		ChargeHeldItem,
		UseTZPInhalant,
		LostInFacility,
		TransferLoot,
		RescueAndRevive,
		GrabLoadout,
		CollectPurchasedItems,
		HealPlayer
	}
	public enum EnumBotSpawnState
	{
		Unknown,
		NotSpawned,
		Spawned
	}
	public enum EnumDefaultAIState
	{
		Dynamic,
		FollowPlayer,
		SearchForScrap,
		ShipDuty,
		TransferLoot
	}
	public enum EnumFearQueryType
	{
		BotPanic,
		PlayerTeleport,
		PathfindingAvoid
	}
	public enum EnumGrabbableObjectCall
	{
		Default,
		Selling,
		Reviving
	}
	public enum EnumLookAtPriority
	{
		LOW_PRIORITY,
		MEDIUM_PRIORITY,
		HIGH_PRIORITY,
		MAXIMUM_PRIORITY
	}
	public enum EnumObjectsLookingAt
	{
		Forward,
		Position
	}
	public enum EnumOptionNames
	{
		Default,
		DefaultCustomList,
		UserCustomList
	}
	public enum EnumOptionSuitChange
	{
		Manual,
		AutomaticSameAsPlayer
	}
	public enum EnumOptionSuitConfig
	{
		Fixed,
		Random
	}
	public enum QueuePriority
	{
		Critical,
		High,
		Normal,
		Low
	}
	public enum EnumSpawnAnimation
	{
		None,
		OnlyPlayerSpawnAnimation,
		OnlyPlayerSpawnAnimationIfDead,
		ReinitializePlayer
	}
	public enum EnumStateControllerMovement
	{
		FollowAgent,
		Free,
		Fixed
	}
	public enum EnumStatusIdentity
	{
		Available,
		ToSpawn,
		Spawned
	}
	public enum EnumTalkativeness
	{
		NoTalking,
		Shy,
		Normal,
		Talkative,
		CantStopTalking
	}
	public enum EnumTerminalStates
	{
		Error,
		WaitForMainCommand,
		Info,
		ConfirmCancelPurchase,
		AbortLanding,
		ConfirmCancelAbortLanding,
		Status
	}
	[Serializable]
	public enum EnumVoicesState
	{
		None,
		Chilling,
		EnteringCruiser,
		FollowingPlayer,
		FoundLoot,
		HearsPlayer,
		Hit,
		LosingPlayer,
		Lost,
		LostAndFound,
		RunningFromMonster,
		SteppedOnTrap,
		Sinking,
		AttackingWithGun,
		AttackingWithMelee,
		OrderedToStay,
		OrderedToFollow
	}
}
namespace LethalBots.Constants
{
	public class ConfigConst
	{
		public const string ConfigSectionMain = "1. General Settings";

		public const string ConfigSectionIdentities = "2. Bot identities";

		public const string ConfigSectionBehavior = "3. Behavior";

		public const string ConfigSectionTeleporters = "4. Teleporters";

		public const string ConfigSectionVoices = "5. Voices";

		public const string ConfigSectionVoiceRecognition = "6. Voice Recognition";

		public const string ConfigSectionDebug = "7. Debug";

		public const int DEFAULT_MAX_BOTS_AVAILABLE = 16;

		public const int MIN_BOTS_AVAILABLE = 0;

		public const int MAX_BOTS_AVAILABLE = 50;

		public const string DEFAULT_BOT_NAME = "Bot #{0}";

		public const EnumOptionSuitChange DEFAULT_CONFIG_ENUM_LETHALBOT_SUIT_CHANGE = EnumOptionSuitChange.Manual;

		public const int DEFAULT_MAX_IDENTITIES = 22;

		public const int MIN_IDENTITIES = 10;

		public const int MAX_IDENTITIES = 200;

		public const string FILE_NAME_GAME_ITEMS = "GameItems.txt";

		public const string FILE_NAME_CONFIG_IDENTITIES = "ConfigIdentities.json";

		public const string FILE_NAME_CONFIG_LOADOUTS = "ConfigLoadouts.json";

		public const string FILE_NAME_CONFIG_STOCK_REQUIREMENTS = "ConfigStockRequirements.json";

		public static readonly ConfigIdentity DEFAULT_CONFIG_IDENTITY = new ConfigIdentity();

		public static readonly ConfigLoadout DEFAULT_CONFIG_LOADOUT = new ConfigLoadout();

		public static readonly ConfigStockRequirement DEFAULT_CONFIG_STOCK_REQUIREMENT = new ConfigStockRequirement();
	}
	public class Const
	{
		public const string CSYNC_GUID = "com.sigurd.csync";

		public const string SPEECHRECOGNITIONAPI_GUID = "JS03.SpeechRecognitionAPI";

		public const string MORECOMPANY_GUID = "me.swipez.melonloader.morecompany";

		public const string BETTER_EXP_GUID = "Swaggies.BetterEXP";

		public const string MOREEMOTES_GUID = "MoreEmotes";

		public const string BETTEREMOTES_GUID = "BetterEmotes";

		public const string MODELREPLACEMENT_GUID = "meow.ModelReplacementAPI";

		public const string LETHALPHONES_GUID = "LethalPhones";

		public const string GENERAL_IMPROVEMENTS_GUID = "ShaosilGaming.GeneralImprovements";

		public const string FASTERITEMDROPSHIP_GUID = "FlipMods.FasterItemDropship";

		public const string SHOWCAPACITY_GUID = "Piggy.ShowCapacity";

		public const string REVIVECOMPANY_GUID = "OpJosMod.ReviveCompany";

		public const string BUNKBEDREVIVE_GUID = "viviko.BunkbedRevive";

		public const string ZAPRILLATOR_GUID = "Zaprillator";

		public const string TOOMANYEMOTES_GUID = "FlipMods.TooManyEmotes";

		public const string RESERVEDITEMSLOTCORE_GUID = "FlipMods.ReservedItemSlotCore";

		public const string LETHALPROGRESSION_GUID = "Stoneman.LethalProgression";

		public const string LETHALINTERNS_GUID = "Szumi57.LethalInterns";

		public const string CUSTOMITEMBEHAVIOURLIBRARY_GUID = "com.github.WhiteSpike.CustomItemBehaviourLibrary";

		public const string LCALWAYSHEARWALKIEMOD_GUID = "suskitech.LCAlwaysHearActiveWalkie";

		public const string BUTTERYFIXES_GUID = "butterystancakes.lethalcompany.butteryfixes";

		public const string PEEPERS_GUID = "x753.Peepers";

		public const string LETHALMIN_GUID = "NoteBoxz.LethalMin";

		public const string FACILITYMELTDOWN_GUID = "me.loaforc.facilitymeltdown";

		public const string NAVMESHINCOMPANY_GUID = "dev.kittenji.NavMeshInCompany";

		public const string ADDITIONALNETWORKING_DLLFILENAME = "AdditionalNetworking_Preloader.dll";

		public const float EPSILON = 0.01f;

		public const bool DISABLE_ORIGINAL_GAME_DEBUG_LOGS = false;

		public const ulong LETHAL_BOT_ACTUAL_ID_OFFSET = 200000uL;

		public const float LETHAL_BOT_FOV = 90f;

		public const int LETHAL_BOT_ENTITIES_RANGE = 40;

		public const float LETHAL_BOT_OBJECT_AWARNESS = 4f;

		public const float LETHAL_BOT_OBJECT_RANGE = 15f;

		public const float WAIT_TIME_FOR_GRAB_DROPPED_OBJECTS = 10f;

		public const float COLLISION_RANGE = 2.8f;

		public const float CLIMB_SPEED = 8f;

		public const int INIT_RAGDOLL_ID = -2;

		public const float LETHAL_BOT_TIMER_LEAVE_PLANET = 5f;

		public const float TIMER_CHECK_EXPOSED = 0.9f;

		public const float AGENT_SPEED = 3.5f;

		public const float AGENT_SPEED_CROUCH = 1.75f;

		public const float BASE_MAX_SPEED = 0.9f;

		public const float BASE_MIN_SPEED = 0.01f;

		public const float BODY_TURNSPEED = 6f;

		public const float CAMERA_TURNSPEED = 4f;

		public const float DISTANCE_CLOSE_ENOUGH_TO_DESTINATION = 1f;

		public const float DISTANCE_CHECK_FOR_HOLES = 2.5f;

		public const float DISTANCE_ITEMS_TO_ENTRANCE = 6f;

		public const int EXPERIMENTATION_MOON_ID = 0;

		public const int ASSURANCE_MOON_ID = 1;

		public const int VOW_MOON_ID = 2;

		public const int COMPANY_BUILDING_MOON_ID = 3;

		public const int MARCH_MOON_ID = 3;

		public const int ADAMANCE_MOON_ID = 4;

		public const int REND_MOON_ID = 5;

		public const int DINE_MOON_ID = 6;

		public const int OFFENSE_MOON_ID = 7;

		public const int TITAN_MOON_ID = 8;

		public const int ARTIFICE_MOON_ID = 9;

		public const int LIQUIDATION_MOON_ID = 10;

		public const int EMBRION_MOON_ID = 11;

		public const float SHIP_EXPANDING_BOUNDS_DIFFERENCE = 10f;

		public const int PLAYER_MASK = 8;

		public const float MAX_CHAT_RANGE = 25f;

		public const float MAX_VOICE_CHAT_RANGE = 40f;

		public const int INVALID_ITEM_SLOT = -1;

		public const int RESERVED_EQUIPMENT_SLOT = 50;

		public const string PLAYER_ANIMATION_WEIGHT_HOLDINGITEMSRIGHTHAND = "HoldingItemsRightHand";

		public const string PLAYER_ANIMATION_WEIGHT_HOLDINGITEMSBOTHHANDS = "HoldingItemsBothHands";

		public const string PLAYER_ANIMATION_WEIGHT_SPECIALANIMATIONS = "SpecialAnimations";

		public const string PLAYER_ANIMATION_WEIGHT_EMOTESNOARMS = "EmotesNoArms";

		public const string PLAYER_ANIMATION_BOOL_GRAB = "Grab";

		public const string PLAYER_ANIMATION_BOOL_GRABVALIDATED = "GrabValidated";

		public const string PLAYER_ANIMATION_BOOL_GRABINVALIDATED = "GrabInvalidated";

		public const string PLAYER_ANIMATION_BOOL_CANCELHOLDING = "cancelHolding";

		public const string PLAYER_ANIMATION_BOOL_SWITCHHOLDANIMATION = "SwitchHoldAnimation";

		public const string PLAYER_ANIMATION_BOOL_SWITCHHOLDANIMATIONTWOHANDED = "SwitchHoldAnimationTwoHanded";

		public const string PLAYER_ANIMATION_BOOL_WALKING = "Walking";

		public const string PLAYER_ANIMATION_BOOL_SPRINTING = "Sprinting";

		public const string PLAYER_ANIMATION_BOOL_SIDEWAYS = "Sideways";

		public const string PLAYER_ANIMATION_BOOL_ANIMATIONSPEED = "animationSpeed";

		public const string PLAYER_ANIMATION_BOOL_HINDEREDMOVEMENT = "hinderedMovement";

		public const string PLAYER_ANIMATION_BOOL_CROUCHING = "crouching";

		public const string PLAYER_ANIMATION_BOOL_FALLNOJUMP = "FallNoJump";

		public const string PLAYER_ANIMATION_BOOL_SHORTFALLLANDING = "ShortFallLanding";

		public const string PLAYER_ANIMATION_BOOL_LIMP = "Limp";

		public const string PLAYER_ANIMATION_TRIGGER_THROW = "Throw";

		public const string PLAYER_ANIMATION_TRIGGER_DAMAGE = "Damage";

		public const string PLAYER_ANINATION_TRIGGER_TERMINAL = "Terminal";

		public const string PLAYER_ANIMATION_TRIGGER_SHORTFALLLANDING = "ShortFallLanding";

		public const string PLAYER_ANIMATION_FLOAT_ANIMATIONSPEED = "animationSpeed";

		public const string PLAYER_ANIMATION_FLOAT_TIREDAMOUNT = "tiredAmount";

		public const string MAPDOT_ANIMATION_BOOL_DEAD = "dead";

		public const int IDLE_STATE_HASH = -1437577361;

		public const int WALKING_STATE_HASH = 81563449;

		public const int SPRINTING_STATE_HASH = -350224702;

		public const int CROUCHING_IDLE_STATE_HASH = 1917280335;

		public const int CROUCHING_WALKING_STATE_HASH = -483816927;

		public const string JESTER_COMMAND = "jester";

		public const string MAN_THE_SHIP_COMMAND = "man the ship";

		public const string TRANSFER_LOOT_COMMAND = "transfer loot";

		public const string GEAR_UP_COMMAND = "gear up";

		public const string START_THE_SHIP_COMMAND = "start the ship";

		public const string REQUEST_MONITORING_COMMAND = "request monitoring";

		public const string CLEAR_MONITORING_COMMAND = "clear monitoring";

		public const string REQUEST_TELEPORT_COMMAND = "request teleport";

		public const string HOP_OFF_THE_TERMINAL_COMMAND = "hop off the terminal";

		public const string USE_KEY_COMMAND = "use key";

		public const string JOIN_GROUP_COMMAND = "join group";

		public const string LEAVE_GROUP_COMMAND = "leave group";

		public const string CREATE_GROUP_COMMAND = "create group";

		public const string RETURN_COMMAND = "return";

		public const float MIN_TIME_TO_VOTE = 0.5f;

		public const float MAX_TIME_TO_VOTE = 1.5f;

		public const float MIN_TIME_SPRINT_SEARCH_WANDER = 1f;

		public const float MAX_TIME_SPRINT_SEARCH_WANDER = 3f;

		public const float MAX_TIME_SEARCH_FOR_PLAYER = 20f;

		public const float DISTANCE_START_RUNNING = 8f;

		public const float DISTANCE_STOP_RUNNING = 7f;

		public const float DISTANCE_CLOSE_ENOUGH_HOR = 5f;

		public const float DISTANCE_CLOSE_ENOUGH_VER = 2f;

		public const float DISTANCE_AWARENESS_HOR = 25f;

		public const float DISTANCE_AWARENESS_VER = 50f;

		public const float TIMER_LOOKING_AROUND = 6f;

		public const float DISTANCE_STOP_SPRINT_LAST_KNOWN_POSITION = 2f;

		public const float WAIT_TIME_TO_TELEPORT = 1f;

		public const float DISTANCE_TO_ENTRANCE = 4f;

		public const float MIN_TIME_FREEZE_LOOKING_AROUND = 0.5f;

		public const float MAX_TIME_FREEZE_LOOKING_AROUND = 2f;

		public const float TIMER_STUCK_TOO_MUCH = 2f;

		public const float DISTANCE_TO_SHIP_BOUND_CLOSEST_POINT = 1f;

		public const float DISTANCE_OF_DROPPED_OBJECT_SHIP_BOUND_CLOSEST_POINT = 2f;

		public static readonly Vector3 POS1_ENTRY_LETHALBOT_CRUISER = new Vector3(-0.5f, -1f, -5.5f);

		public static readonly Vector3 POS2_ENTRY_LETHALBOT_CRUISER = new Vector3(0.9f, -1f, -5.5f);

		public static readonly Vector3 FIRST_CORNER_LETHALBOT_IN_CRUISER = new Vector3(-0.5f, -0.5f, -0.4f);

		public static readonly Vector3 SECOND_CORNER_LETHALBOT_IN_CRUISER = new Vector3(0.9f, -0.5f, -2.5f);

		public const float DISTANCE_FLEEING = 20f;

		public const float DISTANCE_FLEEING_NO_LOS = 5f;

		public const float FLEEING_UPDATE_ENTRANCE = 2f;

		public const float DISTANCE_NEARBY_ENTRANCE = 20f;

		public const float FLEEING_CALM_DOWN_TIME = 10f;

		public const float FLEEING_BREAK_LOS_TIME = 4f;

		public const float FLEEING_UPDATE_FALLBACK_TIME = 5f;

		public const float DISTANCE_TO_CHILL_POINT = 2f;

		public const float RETURN_UPDATE_ENTRANCE = 10f;

		public const float DRUNKNESS_CUTOFF = 0.15f;

		public const float TIMER_CHILL_AT_SHIP = 20f;

		public const float TIMER_CHILL_AT_SHIP_AT_COMPANY = 2f;

		public const float MAX_STRAGGLER_DISTANCE_HOR = 12.5f;

		public const float MAX_STRAGGLER_DISTANCE_VER = 25f;

		public const float TIMER_SEARCH_FOR_SCRAP = 60f;

		public const float TIMER_CHECK_FOR_TRAPPED_PLAYER = 2.5f;

		public const float MIN_TIME_SEARCH_LOOKING_AROUND = 2f;

		public const float MAX_TIME_SEARCH_LOOKING_AROUND = 10f;

		public const float WAIT_TIME_FOR_SAFE_PATH = 60f;

		public const int MAX_ENTRANCE_ATTEMPTS = 3;

		public const float TRANSFER_LOOT_MAX_WAIT_TIME = 30f;

		public const float DISTANCE_FROM_INVERSE_TELEPORTER = 1.5f;

		public const float TIMER_USE_KEY_UNSTUCK = 3f;

		public const float DISTANCE_TO_COMPANY_DESK = 3f;

		public const float DISTANCE_TO_WAIT_AT_DESK = 10f;

		public const float DISTANCE_TO_WAIT_FOR_DROPSHIP = 10f;

		public const float DISTANCE_FALLBACK_FROM_DROPSHIP = 8f;

		public const float DISTANCE_ITEM_TO_COLLECT = 10f;

		public const int MAX_GRAB_OBJECT_ATTEMPTS = 3;

		public const float TIMER_NEXT_ENEMY_CALL = 60f;

		public const float LETHAL_BOT_TIMER_WAIT_FOR_TERMINAL = 5f;

		public const string TRANSMIT_KEYWORD = "transmit";

		public static readonly int TRANSMIT_KEYWORD_LENGTH = "transmit".Length;

		public const float LETHAL_BOT_RESCUE_RANGE = 30f;

		public const float DISTANCE_CLOSE_ENOUGH_TO_HEAL_TARGET = 3f;

		public const float LETHAL_BOT_HEAL_RANGE = 30f;

		public const float DISTANCE_NPCBODY_FROM_LADDER = 2.5f;

		public const float DISTANCE_NPCBODY_FROM_DOOR = 2.5f;

		public const float TIMER_CHECK_DOOR = 0.9f;

		public const float TIMER_USE_ELEVATOR = 4f;

		public const float DISTANCE_TO_ELEVATOR_BOTTOM = 10f;

		public const float DISTANCE_TO_ELEVATOR_TOP = 20f;

		public const float LETHAL_BOT_DROWN_TIME = 12f;

		public const int LETHAL_BOT_LANDMINE_NAVAREA = 26;

		public const int LETHAL_BOT_QUICKSAND_NAVAREA = 27;

		public const int LETHAL_BOT_BRIDGE_NAVAREA = 28;

		public const int LETHAL_BOT_ONLY_NAVAREA = 29;

		public const short LETHAL_PHONES_NO_CALLER_ID = -1;

		public const float LETHAL_PHONES_CLOSED_PHONE = 0f;

		public const float LETHAL_PHONES_OPEN_PHONE = 1f;

		public const string TOOLTIP_DROP_ITEM = "Drop your item : [{0}]";

		public const string TOOLTIP_FOLLOW_ME = "Follow me: [{0}]";

		public const string TOOLTIP_LEAD_THE_WAY = "Lead the way: [{0}]";

		public const string TOOLTIP_CHANGE_SUIT_BOTS = "Change suit : [{0}]";

		public const string TOOLTIP_MAKE_BOT_LOOK = "Make bots look : [{0}]";

		public const string TOOLTIPS_ORDER_1 = "order 1 : [{0}]";
	}
	public class DebugConst
	{
		public const bool DRAW_LINES = false;

		public const bool SHOW_LOG_DEBUG_ONTRANSFORMPARENTCHANGED = false;

		public const bool SPAWN_INTERN_WITH_EMOTE = false;

		public const bool NO_DAMAGE = false;

		public const bool NO_DEATH = false;

		public const bool SPAWN_BUSH_WOLVES_FOR_DEBUG = false;

		public const bool SPAWN_MINESHAFT_FOR_DEBUG = false;

		public const bool TEST_MORE_THAN_X_PLAYER_BYPASS = false;
	}
	public class TerminalConst
	{
		public const int INDEX_DEFAULT_TERMINALNODE = 13;

		public const string STRING_HELP = "help";

		public const string STRING_STORE = "store";

		public const string STRING_MOONS = "moons";

		public const string STRING_OTHER_HELP = "other";

		public const string STRING_BUY_COMMAND = "buy {0} {1}";

		public const string STRING_ROUTE_COMMAND = "route {0}";

		public const string STRING_CONFIRM_COMMAND = "confirm";

		public const string STRING_CANCEL_COMMAND = "deny";

		public const string STRING_TRANSMIT_COMMAND = "transmit {0}";

		public const string STRING_COMPANY_BUILDING = "The Company building";
	}
	public class VoicesConst
	{
		public const EnumTalkativeness DEFAULT_CONFIG_ENUM_TALKATIVENESS = EnumTalkativeness.Normal;

		public const float DISTANCE_HEAR_OTHER_BOTS = 10f;

		public const string SWEAR_KEYWORD = "_cuss";

		public const string INSIDE_KEYWORD = "_inside";

		public const string OUTSIDE_KEYWORD = "_outside";

		public const int MIN_COOLDOWN_PLAYVOICE_SHY = 10;

		public const int MAX_COOLDOWN_PLAYVOICE_SHY = 40;

		public const int MIN_COOLDOWN_PLAYVOICE_NORMAL = 5;

		public const int MAX_COOLDOWN_PLAYVOICE_NORMAL = 20;

		public const int MIN_COOLDOWN_PLAYVOICE_TALKATIVE = 2;

		public const int MAX_COOLDOWN_PLAYVOICE_TALKATIVE = 10;

		public const int MIN_COOLDOWN_PLAYVOICE_CANTSTOPTALKING = 0;

		public const int MAX_COOLDOWN_PLAYVOICE_CANTSTOPTALKING = 0;
	}
}
namespace LethalBots.Configs
{
	public class Config : SyncedConfig2<Config>
	{
		[SyncedEntryField]
		public SyncedEntry<int> MaxBotsAllowedToSpawn;

		[SyncedEntryField]
		public SyncedEntry<bool> AllowBotsInOrbit;

		public ConfigEntry<bool> DisableNameBillBoards;

		[SyncedEntryField]
		public SyncedEntry<bool> SpawnIdentitiesRandomly;

		[SyncedEntryField]
		public SyncedEntry<bool> ResetIdentitiesWhenFired;

		public ConfigEntry<bool> ResetIdentities;

		[SyncedEntryField]
		public SyncedEntry<bool> FollowCrouchWithPlayer;

		[SyncedEntryField]
		public SyncedEntry<bool> ChangeSuitAutoBehaviour;

		[SyncedEntryField]
		public SyncedEntry<bool> AllowBotsToChat;

		[SyncedEntryField]
		public SyncedEntry<bool> AllowMissionControlTeleport;

		[SyncedEntryField]
		public SyncedEntry<bool> StartShipChatCommandProtection;

		[SyncedEntryField]
		public SyncedEntry<bool> AutoMissionControl;

		[SyncedEntryField]
		public SyncedEntry<bool> AutoRouteToCompany;

		[SyncedEntryField]
		public SyncedEntry<int> RestockEcoLimit;

		[SyncedEntryField]
		public SyncedEntry<float> ReturnToShipTime;

		[SyncedEntryField]
		public SyncedEntry<bool> TeleportWhenUsingLadders;

		[SyncedEntryField]
		public SyncedEntry<bool> SellAllScrapOnShip;

		[SyncedEntryField]
		public SyncedEntry<bool> DropHeldEquipmentAtShip;

		[SyncedEntryField]
		public SyncedEntry<bool> ShouldKillEverything;

		[SyncedEntryField]
		public SyncedEntry<bool> GrabItemsNearEntrances;

		[SyncedEntryField]
		public SyncedEntry<bool> GrabBeesNest;

		[SyncedEntryField]
		public SyncedEntry<bool> GrabDeadBodies;

		[SyncedEntryField]
		public SyncedEntry<bool> GrabDockedApparatus;

		[SyncedEntryField]
		public SyncedEntry<bool> TakeCareOfManeaterBaby;

		[SyncedEntryField]
		public SyncedEntry<bool> AdvancedManeaterBabyAI;

		[SyncedEntryField]
		public SyncedEntry<bool> GrabWheelbarrow;

		[SyncedEntryField]
		public SyncedEntry<bool> GrabShoppingCart;

		public ConfigEntry<bool> AllowVoiceRecognition;

		public ConfigEntry<float> VoiceRecognitionSimilarityThreshold;

		public ConfigEntry<int> Talkativeness;

		public ConfigEntry<bool> AllowSwearing;

		[SyncedEntryField]
		public SyncedEntry<bool> AllowTalkingWhileDead;

		public ConfigEntry<bool> EnableDebugLog;

		public ConfigIdentities ConfigIdentities;

		public ConfigLoadouts ConfigLoadouts;

		public ConfigStockRequirements ConfigStockRequirements;

		public Config(ConfigFile cfg)
			: base("LethalBots")
		{
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Expected O, but got Unknown
			//IL_01b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c1: Expected O, but got Unknown
			//IL_01f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fa: Expected O, but got Unknown
			//IL_0395: Unknown result type (might be due to invalid IL or missing references)
			//IL_039f: Expected O, but got Unknown
			//IL_03f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_03fc: Expected O, but got Unknown
			cfg.SaveOnConfigSet = false;
			MaxBotsAllowedToSpawn = SyncedBindingExtensions.BindSyncedEntry<int>(cfg, "1. General Settings", "Max amount of bots that can spawn", 16, new ConfigDescription("Be aware of possible performance problems when more than ~16 bots spawned", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 50), Array.Empty<object>()));
			AllowBotsInOrbit = SyncedBindingExtensions.BindSyncedEntry<bool>(cfg, "1. General Settings", "Allow bots in orbit (YOU MUST HAVE NavmeshInCompany!)", true, "Are bots allowed to stay on the ship while its in orbit? If false, bots will automatically leave and rejoin between rounds.");
			DisableNameBillBoards = cfg.Bind<bool>("1. General Settings", "Should bots have their name tags disabled (Client only)", false, "Although bots call the base game name billboard display code, you can manually disable their name tags here.");
			SpawnIdentitiesRandomly = SyncedBindingExtensions.BindSyncedEntry<bool>(cfg, "2. Bot identities", "Randomness of identities", false, "Spawn the bot with random identities from the file rather than in order?");
			ResetIdentitiesWhenFired = SyncedBindingExtensions.BindSyncedEntry<bool>(cfg, "2. Bot identities", "Reset identities when fired", false, "Should the LethalBotManager reset all identities after the game over fired screen? (NOTE: This will make bots lose all progress and levels in that identity!)");
			ResetIdentities = cfg.Bind<bool>("2. Bot identities", "Reset identities (Host only)", false, "Should the SaveManager reset all identities next time you start a save file? (NOTE: This will automatically set itself to false when after it deletes the bot's save file. This will make bots lose all progress and levels in all identities!)");
			FollowCrouchWithPlayer = SyncedBindingExtensions.BindSyncedEntry<bool>(cfg, "3. Behavior", "Crouch with player", true, "Should the bot crouch like the player is crouching? (NOTE: This will not affect the dynamic crouching AI!)");
			ChangeSuitAutoBehaviour = SyncedBindingExtensions.BindSyncedEntry<bool>(cfg, "3. Behavior", "Options for automaticaly switch suit", false, "Should the bot automatically switch to the same suit as the player who they are assigned to?");
			AllowBotsToChat = SyncedBindingExtensions.BindSyncedEntry<bool>(cfg, "3. Behavior", "Allow using chat", true, "Should the bot be allowed to use the chat? (NOTE: This is useful if you don't want bots spamming the chat! Also this doesn't affect bots calling out jesters!)");
			AllowMissionControlTeleport = SyncedBindingExtensions.BindSyncedEntry<bool>(cfg, "3. Behavior", "Allow the mission controller to teleport living players", true, "Should the bot who is the active mission controller be allowed to teleport living players. (NOTE: This doesn't affect dead body teleportation or if a player specifically request to be teleported!)");
			StartShipChatCommandProtection = SyncedBindingExtensions.BindSyncedEntry<bool>(cfg, "3. Behavior", "Start the ship chat command protection", true, "Should non-host players be allowed to tell the mission controller bot to start the ship? (NOTE: Bots will allow non-host players to start the ship if the host is dead regardless of this option!)");
			AutoMissionControl = SyncedBindingExtensions.BindSyncedEntry<bool>(cfg, "3. Behavior", "Allow automatic mission control assignment", true, "Should bots that are chilling at the ship automatically assume the mission control state if the current mission controller is not set or dead?");
			AutoRouteToCompany = SyncedBindingExtensions.BindSyncedEntry<bool>(cfg, "3. Behavior", "Auto Route To Company", true, "Should the bot who is the active mission controller automatically route to the company building when there are 0 days left in the profit quota?");
			RestockEcoLimit = SyncedBindingExtensions.BindSyncedEntry<int>(cfg, "3. Behavior", "Bot restock spending limit", 550, new ConfigDescription("How much money should the bot leave in reserve when restocking the ship. This is useful if you want the bot to keep some spare cash on hand.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, int.MaxValue), Array.Empty<object>()));
			ReturnToShipTime = SyncedBindingExtensions.BindSyncedEntry<float>(cfg, "3. Behavior", "Return to ship time", 0.63f, new ConfigDescription("At what time should bots automatically return to the ship. This has to be a normalized value. TIP: 10:00 PM is about 0.9f and the time the ship auto leaves at is 0.996f!", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 1f), Array.Empty<object>()));
			TeleportWhenUsingLadders = SyncedBindingExtensions.BindSyncedEntry<bool>(cfg, "3. Behavior", "Teleport when using ladders", false, "Should the bot just teleport and bypass any animations when using ladders? (Useful if you think the bot tends to get stuck on them!)");
			SellAllScrapOnShip = SyncedBindingExtensions.BindSyncedEntry<bool>(cfg, "3. Behavior", "Sell all scrap on ship", false, "Should the bot sell all scrap on the ship? If false, bots will use advanced AI to only sell to quota! (NOTE: This is useful if you have a mod such as quota rollover and the like!)");
			DropHeldEquipmentAtShip = SyncedBindingExtensions.BindSyncedEntry<bool>(cfg, "3. Behavior", "Drop held equipment at ship", false, "Should the bot drop all equipment its holding when at the ship? If false, bots will hold onto equipment, such as shovels! (NOTE: This doesn't affect bot loadouts or if it returns to the ship on its own!)");
			ShouldKillEverything = SyncedBindingExtensions.BindSyncedEntry<bool>(cfg, "3. Behavior", "Should bots attempt to kill everything", false, "Should bots attempt to kill every enemy in the game, even if they can't be killed normally?");
			GrabItemsNearEntrances = SyncedBindingExtensions.BindSyncedEntry<bool>(cfg, "3. Behavior", "Grab items near entrances", true, "Should the bot grab the items near main entrance and fire exits?");
			GrabBeesNest = SyncedBindingExtensions.BindSyncedEntry<bool>(cfg, "3. Behavior", "Grab bees nests", false, "Should the bot try to grab bees nests? (NOTE: Bots will sell them regardless if this is true or false!)");
			GrabDeadBodies = SyncedBindingExtensions.BindSyncedEntry<bool>(cfg, "3. Behavior", "Grab dead bodies", true, "Should the bot try to grab dead bodies? (NOTE: The bot at the terminal will still teleport them back to the ship!))");
			GrabDockedApparatus = SyncedBindingExtensions.BindSyncedEntry<bool>(cfg, "3. Behavior", "Grab docked apparatus", true, "Is the bot allowed to grab docked apparatuses?");
			TakeCareOfManeaterBaby = SyncedBindingExtensions.BindSyncedEntry<bool>(cfg, "3. Behavior", "Take care of baby maneater", true, "Is the bot allowed to calm down the baby maneater if its crying?");
			AdvancedManeaterBabyAI = SyncedBindingExtensions.BindSyncedEntry<bool>(cfg, "3. Behavior", "Advanced baby maneater AI", false, "Should the bot use advanced AI for taking care of the baby maneater? (WARNING: This is experimental and may cause issues!)");
			GrabWheelbarrow = SyncedBindingExtensions.BindSyncedEntry<bool>(cfg, "3. Behavior", "Grab the wheelbarrow", false, "Should the bot try to grab the wheelbarrow (mod)?");
			GrabShoppingCart = SyncedBindingExtensions.BindSyncedEntry<bool>(cfg, "3. Behavior", "Grab the shopping cart", false, "Should the bot try to grab the shopping cart (mod)?");
			AllowVoiceRecognition = cfg.Bind<bool>("6. Voice Recognition", "Enable bot Voice Recognition (Client only)", true, "Should the bots be able to hear what you say in voice chat. (It would only be used for the voice commands!)");
			VoiceRecognitionSimilarityThreshold = cfg.Bind<float>("6. Voice Recognition", "Voice recognition similarity threshold (Client only)", 0.8f, new ConfigDescription("This is the level of accuracy that would be used by SpeechRecognitionAPI when the bot attempts to determine if the given message was a valid chat command. (Higher numbers means a higher level of accuracy is needed!)", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 1f), Array.Empty<object>()));
			Talkativeness = cfg.Bind<int>("5. Voices", "Talkativeness (Client only)", 2, new ConfigDescription("0: No talking | 1: Shy | 2: Normal | 3: Talkative | 4: Can't stop talking", (AcceptableValueBase)(object)new AcceptableValueRange<int>(Enum.GetValues(typeof(EnumTalkativeness)).Cast<int>().Min(), Enum.GetValues(typeof(EnumTalkativeness)).Cast<int>().Max()), Array.Empty<object>()));
			AllowSwearing = cfg.Bind<bool>("5. Voices", "Swear words (Client only)", false, "Allow the use of swear words in bots voice lines ?");
			AllowTalkingWhileDead = SyncedBindingExtensions.BindSyncedEntry<bool>(cfg, "5. Voices", "Allow bots to talk while dead", true, "Are bots that are dead allowed to talk? (NOTE: Only other dead players can hear them!)");
			EnableDebugLog = cfg.Bind<bool>("7. Debug", "EnableDebugLog  (Client only)", true, "Enable the debug logs used for this mod.");
			ClearUnusedEntries(cfg);
			cfg.SaveOnConfigSet = true;
			ReadAndLoadConfigIdentities();
			ReadAndLoadConfigLoadouts();
			ReadAndLoadConfigStockRequirements();
			ConfigManager.Register<Config>((SyncedConfig2<Config>)(object)this);
		}

		private void LogDebugInConfig(string debugLog)
		{
			if (EnableDebugLog.Value)
			{
				Plugin.Logger.LogDebug((object)debugLog);
			}
		}

		private void ClearUnusedEntries(ConfigFile cfg)
		{
			PropertyInfo property = ((object)cfg).GetType().GetProperty("OrphanedEntries", BindingFlags.Instance | BindingFlags.NonPublic);
			Dictionary<ConfigDefinition, string> dictionary = (Dictionary<ConfigDefinition, string>)property.GetValue(cfg, null);
			dictionary.Clear();
			cfg.Save();
		}

		private void CopyDefaultConfigIdentitiesJson()
		{
			try
			{
				string text = Utility.CombinePaths(new string[2]
				{
					Paths.ConfigPath,
					"LethalBots"
				});
				Directory.CreateDirectory(text);
				string value = ReadJsonResource("LethalBots.Configs.ConfigIdentities.json");
				using StreamWriter streamWriter = new StreamWriter(Utility.CombinePaths(new string[2] { text, "ConfigIdentities.json" }));
				streamWriter.WriteLine(value);
			}
			catch (Exception arg)
			{
				Plugin.Logger.LogError((object)$"Error while CopyDefaultConfigIdentitiesJson ! {arg}");
			}
		}

		private void CopyDefaultConfigLoadoutsJson()
		{
			try
			{
				string text = Utility.CombinePaths(new string[2]
				{
					Paths.ConfigPath,
					"LethalBots"
				});
				Directory.CreateDirectory(text);
				string value = ReadJsonResource("LethalBots.Configs.ConfigLoadouts.json");
				using StreamWriter streamWriter = new StreamWriter(Utility.CombinePaths(new string[2] { text, "ConfigLoadouts.json" }));
				streamWriter.WriteLine(value);
			}
			catch (Exception arg)
			{
				Plugin.Logger.LogError((object)$"Error while CopyDefaultConfigLoadoutsJson ! {arg}");
			}
		}

		private void CopyDefaultConfigStockRequirementsJson()
		{
			try
			{
				string text = Utility.CombinePaths(new string[2]
				{
					Paths.ConfigPath,
					"LethalBots"
				});
				Directory.CreateDirectory(text);
				string value = ReadJsonResource("LethalBots.Configs.ConfigStockRequirements.json");
				using StreamWriter streamWriter = new StreamWriter(Utility.CombinePaths(new string[2] { text, "ConfigStockRequirements.json" }));
				streamWriter.WriteLine(value);
			}
			catch (Exception arg)
			{
				Plugin.Logger.LogError((object)$"Error while CopyDefaultConfigStockRequirementsJson! {arg}");
			}
		}

		private string ReadJsonResource(string resourceName)
		{
			Assembly executingAssembly = Assembly.GetExecutingAssembly();
			using Stream stream = executingAssembly.GetManifestResourceStream(resourceName);
			using StreamReader streamReader = new StreamReader(stream);
			return streamReader.ReadToEnd();
		}

		private void ReadAndLoadConfigIdentities()
		{
			string text = "No path yet";
			string text2;
			try
			{
				text = Utility.CombinePaths(new string[3]
				{
					Paths.ConfigPath,
					"LethalBots",
					"ConfigIdentities.json"
				});
				if (File.Exists(text))
				{
					Plugin.Logger.LogInfo((object)"Identities file found! Reading...");
					using (StreamReader streamReader = new StreamReader(text))
					{
						text2 = streamReader.ReadToEnd();
					}
					ConfigIdentities = JsonUtility.FromJson<ConfigIdentities>(text2);
					if (ConfigIdentities.configIdentities == null)
					{
						Plugin.Logger.LogWarning((object)("Unknown to read identities from file at " + text));
					}
				}
				else
				{
					Plugin.Logger.LogInfo((object)"No identities file found. Creating new file with default identities...");
					CopyDefaultConfigIdentitiesJson();
					text = "LethalBots.Configs.ConfigIdentities.json";
					text2 = ReadJsonResource(text);
					ConfigIdentities = JsonUtility.FromJson<ConfigIdentities>(text2);
				}
			}
			catch (Exception arg)
			{
				Plugin.Logger.LogError((object)$"Error while ReadAndLoadConfigIdentitiesFromUser! {arg}");
				text2 = "No json, see exception above.";
			}
			if (ConfigIdentities.configIdentities == null)
			{
				Plugin.Logger.LogWarning((object)("A problem occured while retrieving identities from config file! continuing with no identities... json used : \n" + text2));
				ConfigIdentities = new ConfigIdentities
				{
					configIdentities = new ConfigIdentity[0]
				};
				return;
			}
			Plugin.Logger.LogInfo((object)$"Loaded {ConfigIdentities.configIdentities.Length} identities from file : {text}");
			ConfigIdentity[] configIdentities = ConfigIdentities.configIdentities;
			for (int i = 0; i < configIdentities.Length; i++)
			{
				ConfigIdentity configIdentity = configIdentities[i];
				LogDebugInConfig(configIdentity.ToString() ?? "");
			}
		}

		private void ReadAndLoadConfigLoadouts()
		{
			string text = "No path yet";
			string text2;
			try
			{
				text = Utility.CombinePaths(new string[3]
				{
					Paths.ConfigPath,
					"LethalBots",
					"ConfigLoadouts.json"
				});
				if (File.Exists(text))
				{
					Plugin.Logger.LogInfo((object)"Loadouts file found! Reading...");
					using (StreamReader streamReader = new StreamReader(text))
					{
						text2 = streamReader.ReadToEnd();
					}
					ConfigLoadouts = JsonUtility.FromJson<ConfigLoadouts>(text2);
					if (ConfigLoadouts.configLoadouts == null)
					{
						Plugin.Logger.LogWarning((object)("Unknown to read loadouts from file at " + text));
					}
				}
				else
				{
					Plugin.Logger.LogInfo((object)"No user loadout file found. Creating new file with default loadouts...");
					CopyDefaultConfigLoadoutsJson();
					text = "LethalBots.Configs.ConfigLoadouts.json";
					text2 = ReadJsonResource(text);
					ConfigLoadouts = JsonUtility.FromJson<ConfigLoadouts>(text2);
					if (ConfigLoadouts.configLoadouts != null)
					{
						Plugin.Logger.LogInfo((object)$"Loaded {ConfigLoadouts.configLoadouts.Length} identities from file : {text}");
					}
				}
			}
			catch (Exception arg)
			{
				Plugin.Logger.LogError((object)$"Error while ReadAndLoadConfigLoadouts! {arg}");
				text2 = "No json, see exception above.";
			}
			if (ConfigLoadouts.configLoadouts == null)
			{
				Plugin.Logger.LogWarning((object)("A problem occured while retrieving loadouts from config file! continuing with no loadouts... json used : \n" + text2));
				ConfigLoadouts = new ConfigLoadouts
				{
					configLoadouts = new ConfigLoadout[0]
				};
				return;
			}
			Plugin.Logger.LogInfo((object)$"Loaded {ConfigLoadouts.configLoadouts.Length} loadouts from file : {text}");
			ConfigLoadout[] configLoadouts = ConfigLoadouts.configLoadouts;
			for (int i = 0; i < configLoadouts.Length; i++)
			{
				ConfigLoadout configLoadout = configLoadouts[i];
				LogDebugInConfig(configLoadout.ToString() ?? "");
			}
		}

		private void ReadAndLoadConfigStockRequirements()
		{
			string text = "No path yet";
			string text2;
			try
			{
				text = Utility.CombinePaths(new string[3]
				{
					Paths.ConfigPath,
					"LethalBots",
					"ConfigStockRequirements.json"
				});
				if (File.Exists(text))
				{
					Plugin.Logger.LogInfo((object)"Stock requirements file found! Reading...");
					using (StreamReader streamReader = new StreamReader(text))
					{
						text2 = streamReader.ReadToEnd();
					}
					ConfigStockRequirements = JsonUtility.FromJson<ConfigStockRequirements>(text2);
					if (ConfigStockRequirements.configStockRequirements == null)
					{
						Plugin.Logger.LogWarning((object)("Unknown to read stock requirements from file at " + text));
					}
				}
				else
				{
					Plugin.Logger.LogInfo((object)"No stock requirements file found. Creating new file with default stock requirements...");
					CopyDefaultConfigStockRequirementsJson();
					text = "LethalBots.Configs.ConfigStockRequirements.json";
					text2 = ReadJsonResource(text);
					ConfigStockRequirements = JsonUtility.FromJson<ConfigStockRequirements>(text2);
				}
			}
			catch (Exception arg)
			{
				Plugin.Logger.LogError((object)$"Error while ReadAndLoadConfigStockRequirementsFromUser! {arg}");
				text2 = "No json, see exception above.";
			}
			if (ConfigStockRequirements.configStockRequirements == null)
			{
				Plugin.Logger.LogWarning((object)("A problem occured while retrieving stock requirements from config file! Continuing with no stock requirements... json used : \n" + text2));
				ConfigStockRequirements = new ConfigStockRequirements
				{
					configStockRequirements = new ConfigStockRequirement[0]
				};
				return;
			}
			Plugin.Logger.LogInfo((object)$"Loaded {ConfigStockRequirements.configStockRequirements.Length} stock requirements from file : {text}");
			ConfigStockRequirement[] configStockRequirements = ConfigStockRequirements.configStockRequirements;
			for (int i = 0; i < configStockRequirements.Length; i++)
			{
				ConfigStockRequirement configStockRequirement = configStockRequirements[i];
				LogDebugInConfig(configStockRequirement.ToString() ?? "");
			}
		}
	}
	[Serializable]
	public struct ConfigIdentities
	{
		public ConfigIdentity[] configIdentities;
	}
	[Serializable]
	public struct ConfigLoadouts
	{
		public ConfigLoadout[] configLoadouts;
	}
	[Serializable]
	public struct ConfigStockRequirements
	{
		public ConfigStockRequirement[] configStockRequirements;
	}
}
namespace LethalBots.AI
{
	public abstract class AIState
	{
		protected struct AIStateInfo
		{
			public Vector3? TargetLastKnownPosition;

			public GrabbableObject? TargetItem;
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass72_0
		{
			public Vector3? targetDestination;

			internal float <findSafePathToTarget>b__0(GameObject node)
			{
				//IL_0006: 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_001b: Unknown result type (might be due to invalid IL or missing references)
				Vector3 val = node.transform.position - targetDestination.Value;
				return ((Vector3)(ref val)).sqrMagnitude;
			}
		}

		[CompilerGenerated]
		private sealed class <LookingAround>d__79 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public AIState <>4__this;

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

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

			[DebuggerHidden]
			public <LookingAround>d__79(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0070: Unknown result type (might be due to invalid IL or missing references)
				//IL_0075: Unknown result type (might be due to invalid IL or missing references)
				//IL_007a: Unknown result type (might be due to invalid IL or missing references)
				//IL_007f: Unknown result type (might be due to invalid IL or missing references)
				//IL_00af: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
				//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
				//IL_00de: Unknown result type (might be due to invalid IL or missing references)
				//IL_0104: Unknown result type (might be due to invalid IL or missing references)
				//IL_0119: Unknown result type (might be due to invalid IL or missing references)
				//IL_0123: Expected O, but got Unknown
				//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)
				int num = <>1__state;
				AIState aIState = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = null;
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					break;
				case 2:
					<>1__state = -1;
					break;
				}
				if (aIState.ai.State != null && aIState.ai.State == aIState)
				{
					float num2 = Random.Range(2f, 10f);
					float num3 = Random.Range(0f, 360f);
					Vector3 val = Quaternion.Euler(0f, num3, 0f) * Vector3.forward;
					float num4 = 2f;
					float num5 = 8f;
					float num6 = Random.Range(num4, num5);
					Vector3 lookAtPos = ((Component)aIState.npcController.Npc.gameplayCamera).transform.position + val * num6;
					RaycastHit val2 = default(RaycastHit);
					if (Physics.Raycast(((Component)aIState.npcController.Npc.thisController).transform.position, val, ref val2, num6, StartOfRound.Instance.collidersAndRoomMaskAndDefault))
					{
						lookAtPos = ((RaycastHit)(ref val2)).point;
					}
					aIState.npcController.OrderToLookAtPosition(lookAtPos, EnumLookAtPriority.MEDIUM_PRIORITY, 1f);
					<>2__current = (object)new WaitForSeconds(num2);
					<>1__state = 2;
					return true;
				}
				aIState.lookingAroundCoroutine = null;
				return false;
			}

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

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

		[CompilerGenerated]
		private sealed class <findSafePathToTarget>d__72 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public AIState <>4__this;

			private <>c__DisplayClass72_0 <>8__1;

			private Task<(bool isDangerous, bool isPathValid, float pathDistance)> <pathfindTask>5__2;

			private GameObject[] <nodes>5__3;

			private bool <foundSafePath>5__4;

			private int <i>5__5;

			private Vector3 <nodePos>5__6;

			private bool <ourWeOutside>5__7;

			private float <headOffset>5__8;

			private bool <isNodeSafe>5__9;

			private Vector3 <simulatedHead>5__10;

			private RoundManager <instanceRM>5__11;

			private int <j>5__12;

			private EnemyAI <checkLOSToTarget>5__13;

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

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

			[DebuggerHidden]
			public <findSafePathToTarget>d__72(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>8__1 = null;
				<pathfindTask>5__2 = null;
				<nodes>5__3 = null;
				<instanceRM>5__11 = null;
				<checkLOSToTarget>5__13 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_044c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0466: Unknown result type (might be due to invalid IL or missing references)
				//IL_0284: Unknown result type (might be due to invalid IL or missing references)
				//IL_04e7: Unknown result type (might be due to invalid IL or missing references)
				//IL_05c4: Unknown result type (might be due to invalid IL or missing references)
				//IL_05c9: Unknown result type (might be due to invalid IL or missing references)
				//IL_022a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0231: Unknown result type (might be due to invalid IL or missing references)
				//IL_0237: Unknown result type (might be due to invalid IL or missing references)
				//IL_023f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0244: Unknown result type (might be due to invalid IL or missing references)
				//IL_049e: Unknown result type (might be due to invalid IL or missing references)
				//IL_04a5: Unknown result type (might be due to invalid IL or missing references)
				//IL_04ab: Unknown result type (might be due to invalid IL or missing references)
				//IL_04b3: Unknown result type (might be due to invalid IL or missing references)
				//IL_04b8: Unknown result type (might be due to invalid IL or missing references)
				//IL_050a: Unknown result type (might be due to invalid IL or missing references)
				//IL_050f: Unknown result type (might be due to invalid IL or missing references)
				//IL_051a: Unknown result type (might be due to invalid IL or missing references)
				//IL_051f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0524: Unknown result type (might be due to invalid IL or missing references)
				//IL_05d7: Unknown result type (might be due to invalid IL or missing references)
				//IL_05da: Unknown result type (might be due to invalid IL or missing references)
				//IL_05df: Unknown result type (might be due to invalid IL or missing references)
				//IL_05e4: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
				//IL_036b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0381: Unknown result type (might be due to invalid IL or missing references)
				//IL_038b: Expected O, but got Unknown
				//IL_08d6: Unknown result type (might be due to invalid IL or missing references)
				//IL_08fa: Unknown result type (might be due to invalid IL or missing references)
				//IL_0904: Expected O, but got Unknown
				//IL_0888: Unknown result type (might be due to invalid IL or missing references)
				//IL_0174: Unknown result type (might be due to invalid IL or missing references)
				//IL_0179: Unknown result type (might be due to invalid IL or missing references)
				//IL_0185: Unknown result type (might be due to invalid IL or missing references)
				//IL_019b: Unknown result type (might be due to invalid IL or missing references)
				//IL_01a5: Expected O, but got Unknown
				//IL_0324: Unknown result type (might be due to invalid IL or missing references)
				//IL_0329: Unknown result type (might be due to invalid IL or missing references)
				//IL_08ae: Unknown result type (might be due to invalid IL or missing references)
				//IL_08a7: Unknown result type (might be due to invalid IL or missing references)
				//IL_0795: Unknown result type (might be due to invalid IL or missing references)
				//IL_06dc: Unknown result type (might be due to invalid IL or missing references)
				//IL_08b5: Unknown result type (might be due to invalid IL or missing references)
				//IL_08bb: Unknown result type (might be due to invalid IL or missing references)
				//IL_08c3: Unknown result type (might be due to invalid IL or missing references)
				//IL_08c8: Unknown result type (might be due to invalid IL or missing references)
				//IL_07ae: Unknown result type (might be due to invalid IL or missing references)
				//IL_07c3: Unknown result type (might be due to invalid IL or missing references)
				//IL_07c8: Unknown result type (might be due to invalid IL or missing references)
				//IL_07cd: Unknown result type (might be due to invalid IL or missing references)
				//IL_06ff: Unknown result type (might be due to invalid IL or missing references)
				//IL_0715: Unknown result type (might be due to invalid IL or missing references)
				//IL_071a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0660: Unknown result type (might be due to invalid IL or missing references)
				//IL_0651: Unknown result type (might be due to invalid IL or missing references)
				//IL_0824: Unknown result type (might be due to invalid IL or missing references)
				//IL_081b: Unknown result type (might be due to invalid IL or missing references)
				//IL_07ee: Unknown result type (might be due to invalid IL or missing references)
				//IL_0665: Unknown result type (might be due to invalid IL or missing references)
				//IL_0667: Unknown result type (might be due to invalid IL or missing references)
				//IL_0669: Unknown result type (might be due to invalid IL or missing references)
				//IL_0673: Unknown result type (might be due to invalid IL or missing references)
				//IL_0678: Unknown result type (might be due to invalid IL or missing references)
				//IL_067e: Unknown result type (might be due to invalid IL or missing references)
				//IL_082b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0831: Unknown result type (might be due to invalid IL or missing references)
				//IL_0839: Unknown result type (might be due to invalid IL or missing references)
				//IL_083e: Unknown result type (might be due to invalid IL or missing references)
				//IL_085b: Unknown result type (might be due to invalid IL or missing references)
				int num = <>1__state;
				AIState CS$<>8__locals0 = <>4__this;
				float? fearRangeForEnemies;
				Vector3 position;
				Vector3 val;
				bool flag;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = null;
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					goto IL_092a;
				case 2:
					<>1__state = -1;
					goto IL_00f9;
				case 3:
					<>1__state = -1;
					goto IL_092a;
				case 4:
					<>1__state = -1;
					<foundSafePath>5__4 = false;
					<i>5__5 = 0;
					goto IL_0349;
				case 5:
					<>1__state = -1;
					goto IL_026b;
				case 6:
					<>1__state = -1;
					goto IL_02bb;
				case 7:
					<>1__state = -1;
					goto IL_092a;
				case 8:
					<>1__state = -1;
					<ourWeOutside>5__7 = ((EnemyAI)CS$<>8__locals0.ai).isOutside;
					<headOffset>5__8 = ((Component)CS$<>8__locals0.npcController.Npc.gameplayCamera).transform.position.y - ((Component)CS$<>8__locals0.npcController.Npc).transform.position.y;
					<i>5__5 = 0;
					goto IL_073a;
				case 9:
					<>1__state = -1;
					goto IL_04e0;
				case 10:
					<>1__state = -1;
					goto IL_05a5;
				case 11:
					{
						<>1__state = -1;
						<>8__1 = null;
						<pathfindTask>5__2 = null;
						<nodes>5__3 = null;
						goto IL_092a;
					}
					IL_073a:
					if (<i>5__5 < <nodes>5__3.Length)
					{
						Transform transform = <nodes>5__3[<i>5__5].transform;
						<nodePos>5__6 = RoundManager.Instance.GetNavMeshPosition(transform.position, default(NavMeshHit), 2.7f, -1);
						if (<i>5__5 % 15 == 0)
						{
							<>2__current = null;
							<>1__state = 9;
							return true;
						}
						goto IL_04e0;
					}
					goto IL_074d;
					IL_0349:
					if (<i>5__5 < <nodes>5__3.Length)
					{
						Transform transform2 = <nodes>5__3[<i>5__5].transform;
						<nodePos>5__6 = RoundManager.Instance.GetNavMeshPosition(transform2.position, default(NavMeshHit), 2.7f, -1);
						if (<i>5__5 % 15 == 0)
						{
							<>2__current = null;
							<>1__state = 5;
							return true;
						}
						goto IL_026b;
					}
					goto IL_035c;
					IL_06a5:
					<j>5__12++;
					goto IL_06b7;
					IL_04e0:
					if (CS$<>8__locals0.ai.IsValidPathToTarget(<nodePos>5__6))
					{
						<isNodeSafe>5__9 = true;
						<simulatedHead>5__10 = <nodePos>5__6 + Vector3.up * <headOffset>5__8;
						<instanceRM>5__11 = RoundManager.Instance;
						<j>5__12 = 0;
						goto IL_06b7;
					}
					goto IL_0728;
					IL_0728:
					<i>5__5++;
					goto IL_073a;
					IL_06b7:
					if (<j>5__12 < <instanceRM>5__11.SpawnedEnemies.Count)
					{
						<checkLOSToTarget>5__13 = <instanceRM>5__11.SpawnedEnemies[<j>5__12];
						if (!<checkLOSToTarget>5__13.isEnemyDead && <ourWeOutside>5__7 == <checkLOSToTarget>5__13.isOutside)
						{
							if (<j>5__12 % 10 == 0)
							{
								<>2__current = null;
								<>1__state = 10;
								return true;
							}
							goto IL_05a5;
						}
						goto IL_06a5;
					}
					goto IL_06d2;
					IL_05a5:
					fearRangeForEnemies = CS$<>8__locals0.ai.GetFearRangeForEnemies(<checkLOSToTarget>5__13, EnumFearQueryType.PathfindingAvoid);
					position = ((Component)<checkLOSToTarget>5__13).transform.position;
					if (fearRangeForEnemies.HasValue)
					{
						val = position - <nodePos>5__6;
						if (((Vector3)(ref val)).sqrMagnitude <= fearRangeForEnemies * fearRangeForEnemies)
						{
							Vector3 val2 = (((Object)(object)<checkLOSToTarget>5__13.eye != (Object)null) ? <checkLOSToTarget>5__13.eye.position : position);
							if (!Physics.Linecast(val2 + Vector3.up * 0.2f, <simulatedHead>5__10, StartOfRound.Instance.collidersAndRoomMaskAndDefault, (QueryTriggerInteraction)1))
							{
								<isNodeSafe>5__9 = false;
								goto IL_06d2;
							}
						}
					}
					<checkLOSToTarget>5__13 = null;
					goto IL_06a5;
					IL_026b:
					CS$<>8__locals0.CancelAsyncPathfindToken();
					CS$<>8__locals0.pathfindCancellationToken = new CancellationTokenSource();
					<pathfindTask>5__2 = CS$<>8__locals0.ai.TryStartPathDangerousAsync(<nodePos>5__6, calculatePathDistance: false, useEyePosition: true, checkForEnemies: true, checkForQuicksand: true, CS$<>8__locals0.pathfindCancellationToken.Token);
					goto IL_02bb;
					IL_02bb:
					if (!<pathfindTask>5__2.IsCompleted)
					{
						<>2__current = null;
						<>1__state = 6;
						return true;
					}
					if (<pathfindTask>5__2.IsFaulted)
					{
						Plugin.LogError($"Async pathfinder had an exception: {<pathfindTask>5__2.Exception}");
						CS$<>8__locals0.StopSafePathCoroutine();
						return false;
					}
					if (<pathfindTask>5__2.IsCanceled)
					{
						Plugin.LogWarning("Async pathfinder was canceled early, skipping node!");
					}
					else if (!<pathfindTask>5__2.Result.isDangerous)
					{
						CS$<>8__locals0.safePathPos = <nodePos>5__6;
						<foundSafePath>5__4 = true;
						goto IL_035c;
					}
					<i>5__5++;
					goto IL_0349;
					IL_092a:
					if (CS$<>8__locals0.ai.State != null)
					{
						<>8__1 = new <>c__DisplayClass72_0();
						<>8__1.targetDestination = CS$<>8__locals0.GetDesiredSafePathPosition();
						if (!<>8__1.targetDestination.HasValue)
						{
							CS$<>8__locals0.StopSafePathCoroutine();
							return false;
						}
						CS$<>8__locals0.CancelAsyncPathfindToken();
						CS$<>8__locals0.pathfindCancellationToken = new CancellationTokenSource();
						<pathfindTask>5__2 = CS$<>8__locals0.ai.TryStartPathDangerousAsync(<>8__1.targetDestination.Value, calculatePathDistance: false, useEyePosition: true, checkForEnemies: true, checkForQuicksand: true, CS$<>8__locals0.pathfindCancellationToken.Token);
						goto IL_00f9;
					}
					CS$<>8__locals0.StopSafePathCoroutine();
					return false;
					IL_074d:
					flag = false;
					if (!<foundSafePath>5__4)
					{
						if (!CS$<>8__locals0.npcController.Npc.isUnderwater)
						{
							if (!((EnemyAI)CS$<>8__locals0.ai).agent.isOnNavMesh)
							{
								Transform closestNode = CS$<>8__locals0.GetClosestNode(((Component)CS$<>8__locals0.npcController.Npc).transform.position);
								if ((Object)(object)closestNode != (Object)null)
								{
									val = closestNode.position - ((Component)CS$<>8__locals0.npcController.Npc).transform.position;
									if (((Vector3)(ref val)).sqrMagnitude < 1f)
									{
										closestNode = CS$<>8__locals0.GetClosestNode(((Component)CS$<>8__locals0.npcController.Npc).transform.position, ((Component)closestNode).gameObject);
									}
								}
								CS$<>8__locals0.safePathPos = RoundManager.Instance.GetNavMeshPosition((closestNode != null) ? closestNode.position : ((Component)CS$<>8__locals0.npcController.Npc).transform.position, default(NavMeshHit), 2.7f, -1);
								flag = true;
								Plugin.LogWarning($"Bot {CS$<>8__locals0.npcController.Npc.playerUsername} off NavMesh, setting safePathPos to closest node at {CS$<>8__locals0.safePathPos}");
							}
						}
						else
						{
							RoundManager instance = RoundManager.Instance;
							Transform? closestNode2 = CS$<>8__locals0.GetClosestNode(((Component)CS$<>8__locals0.npcController.Npc).transform.position);
							CS$<>8__locals0.safePathPos = instance.GetNavMeshPosition((closestNode2 != null) ? closestNode2.position : ((Component)CS$<>8__locals0.npcController.Npc).transform.position, default(NavMeshHit), 2.7f, -1);
							flag = true;
						}
					}
					CS$<>8__locals0.ai.SetDestinationToPositionLethalBotAI(CS$<>8__locals0.safePathPos);
					if (flag)
					{
						CS$<>8__locals0.ai.OrderMoveToDestination();
					}
					<>2__current = (object)new WaitForSeconds(((EnemyAI)CS$<>8__locals0.ai).AIIntervalTime);
					<>1__state = 11;
					return true;
					IL_06d2:
					if (!<isNodeSafe>5__9 || CS$<>8__locals0.IsPositionCoveredInQuickSand(<nodePos>5__6, checkClosestNode: false))
					{
						goto IL_0728;
					}
					Plugin.LogDebug($"Bot {CS$<>8__locals0.npcController.Npc.playerUsername} found fallback spot at {<nodePos>5__6}!");
					CS$<>8__locals0.safePathPos = <nodePos>5__6;
					<foundSafePath>5__4 = true;
					goto IL_074d;
					IL_00f9:
					if (!<pathfindTask>5__2.IsCompleted)
					{
						<>2__current = null;
						<>1__state = 2;
						return true;
					}
					if (<pathfindTask>5__2.IsFaulted)
					{
						Plugin.LogError($"Async pathfinder had an exception: {<pathfindTask>5__2.Exception}");
						CS$<>8__locals0.StopSafePathCoroutine();
						return false;
					}
					if (<pathfindTask>5__2.IsCanceled)
					{
						Plugin.LogWarning("Async pathfinder was canceled early!");
					}
					else if (!<pathfindTask>5__2.Result.isDangerous || CS$<>8__locals0.ShouldIgnoreInitialDangerCheck())
					{
						CS$<>8__locals0.safePathPos = <>8__1.targetDestination.Value;
						CS$<>8__locals0.ai.SetDestinationToPositionLethalBotAI(CS$<>8__locals0.safePathPos);
						<>2__current = (object)new WaitForSeconds(((EnemyAI)CS$<>8__locals0.ai).AIIntervalTime);
						<>1__state = 3;
						return true;
					}
					<nodes>5__3 = ((EnemyAI)CS$<>8__locals0.ai).allAINodes.OrderBy(delegate(GameObject node)
					{
						//IL_0006: 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_001b: Unknown result type (might be due to invalid IL or missing references)
						Vector3 val4 = node.transform.position - <>8__1.targetDestination.Value;
						return ((Vector3)(ref val4)).sqrMagnitude;
					}).ToArray();
					<>2__current = null;
					<>1__state = 4;
					return true;
					IL_035c:
					if (<foundSafePath>5__4)
					{
						CS$<>8__locals0.ai.SetDestinationToPositionLethalBotAI(CS$<>8__locals0.safePathPos);
						<>2__current = (object)new WaitForSeconds(((EnemyAI)CS$<>8__locals0.ai).AIIntervalTime);
						<>1__state = 7;
						return true;
					}
					if (CS$<>8__locals0.npcController.Npc.isUnderwater || CS$<>8__locals0.ai.AreWeExposed())
					{
						Plugin.LogDebug("Bot " + CS$<>8__locals0.npcController.Npc.playerUsername + " failed to find a node out of sight and is exposed! They will now attempt to fallback into cover if possible!");
						<nodes>5__3 = ((EnemyAI)CS$<>8__locals0.ai).allAINodes.OrderBy(delegate(GameObject node)
						{
							//IL_0006: Unknown result type (might be due to invalid IL or missing references)
							//IL_001b: Unknown result type (might be due to invalid IL or missing references)
							//IL_0020: Unknown result type (might be due to invalid IL or missing references)
							//IL_0025: Unknown result type (might be due to invalid IL or missing references)
							Vector3 val3 = node.transform.position - ((Component)CS$<>8__locals0.npcController.Npc).transform.position;
							return ((Vector3)(ref val3)).sqrMagnitude;
						}).ToArray();
						<>2__current = null;
						<>1__state = 8;
						return true;
					}
					goto IL_074d;
				}
			}

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

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

		protected AIState? previousAIState;

		private EnumAIStates currentState;

		protected NpcController npcController;

		protected Vector3? targetLastKnownPosition;

		protected AIStateInfo previousStateUpdate;

		protected CountdownTimer useNoiseMakerCooldown = new CountdownTimer();

		protected Coroutine? panikCoroutine;

		protected Coroutine? safePathCoroutine;

		protected Coroutine? lookingAroundCoroutine;

		protected Vector3 safePathPos;

		protected CancellationTokenSource? pathfindCancellationToken;

		protected EntranceTeleport? targetEntrance;

		protected bool hasBeenStarted;

		private GameObject? lastStuckNode;

		private static Dictionary<EntranceTeleport, (bool isSafe, float lastSafetyCheck)> entranceSafetyCache = new Dictionary<EntranceTeleport, (bool, float)>();

		public LethalBotAI ai { get; protected set; }

		public EnumAIStates? previousState { get; protected set; }

		protected EnumAIStates CurrentState
		{
			get
			{
				return currentState;
			}
			set
			{
				currentState = value;
				Plugin.LogDebug($"Bot {npcController.Npc.playerClientId} ({npcController.Npc.playerUsername}) new state :                 {currentState}");
			}
		}

		public EnemyAI? CurrentEnemy { get; protected set; }

		public GrabbableObject? TargetItem { get; protected set; }

		public LethalBotInteraction? LethalBotInteraction { get; protected set; }

		protected AIState(AIState oldState, AIState? changeToOnEnd = null)
			: this(oldState.ai, changeToOnEnd)
		{
			previousAIState = changeToOnEnd ?? oldState;
			previousState = oldState.GetAIState();
			targetLastKnownPosition = oldState.targetLastKnownPosition;
			TargetItem = oldState.TargetItem;
			panikCoroutine = oldState.panikCoroutine;
			CurrentEnemy = oldState.CurrentEnemy;
			useNoiseMakerCooldown = oldState.useNoiseMakerCooldown;
		}

		protected AIState(LethalBotAI ai, AIState? changeToOnEnd = null)
		{
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)ai == (Object)null)
			{
				throw new NullReferenceException("Enemy AI is null.");
			}
			previousAIState = changeToOnEnd;
			this.ai = ai;
			npcController = ai.NpcController;
			safePathPos = ((Component)npcController.Npc).transform.position;
		}

		~AIState()
		{
			CancelAsyncPathfindToken();
		}

		public virtual void OnEnterState()
		{
			//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)
			safePathPos = ((Component)npcController.Npc).transform.position;
			hasBeenStarted = true;
		}

		public virtual void OnExitState(AIState newState)
		{
		}

		public abstract void DoAI();

		public abstract void TryPlayCurrentStateVoiceAudio();

		public virtual void PlayerHeard(Vector3 noisePosition)
		{
		}

		[Obsolete("Broken on purpose! This function is never called and will never be fixed since you can't tell who created a sound!")]
		public virtual void EnemyHeard(Vector3 noisePosition)
		{
		}

		public virtual void OnBotStuck()
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			Transform closestNode = GetClosestNode(((Component)npcController.Npc).transform.position, lastStuckNode);
			lastStuckNode = ((closestNode != null) ? ((Component)closestNode).gameObject : null);
			if ((Object)(object)closestNode != (Object)null)
			{
				ai.SyncTeleportLethalBot(closestNode.position);
			}
		}

		private Transform? GetClosestNode(Vector3 pos, GameObject? ignoreNode = null)
		{
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			GameObject[] array;
			if (((EnemyAI)ai).isOutside)
			{
				if (RoundManager.Instance.outsideAINodes == null)
				{
					RoundManager.Instance.outsideAINodes = GameObject.FindGameObjectsWithTag("OutsideAINode");
				}
				array = RoundManager.Instance.outsideAINodes;
			}
			else
			{
				if (RoundManager.Instance.insideAINodes == null)
				{
					RoundManager.Instance.insideAINodes = GameObject.FindGameObjectsWithTag("AINode");
				}
				array = RoundManager.Instance.insideAINodes;
			}
			float num = 99999f;
			GameObject val = null;
			GameObject[] array2 = array;
			foreach (GameObject val2 in array2)
			{
				if (!((Object)(object)val2 == (Object)null))
				{
					Vector3 val3 = val2.transform.position - pos;
					float sqrMagnitude = ((Vector3)(ref val3)).sqrMagnitude;
					if (sqrMagnitude < num && (Object)(object)ignoreNode != (Object)(object)val2)
					{
						num = sqrMagnitude;
						val = val2;
					}
				}
			}
			if (val == null)
			{
				return null;
			}
			return val.transform;
		}

		public static void RegisterChatCommands()
		{
			ChatCommandsManager.RegisterGlobalCommand(new ChatCommand("jester", delegate(AIState state, LethalBotAI lethalBotAI, PlayerControllerB playerWhoSentMessage, string message, bool isVoice)
			{
				if (((EnemyAI)lethalBotAI).isOutside)
				{
					return false;
				}
				EnemyAI val = state.FindNearbyJester();
				if ((Object)(object)val == (Object)null)
				{
					return false;
				}
				lethalBotAI.State = new PanikState(state, val);
				return true;
			}));
			ChatCommandsManager.RegisterGlobalCommand(new ChatCommand("man the ship", delegate(AIState state, LethalBotAI lethalBotAI, PlayerControllerB playerWhoSentMessage, string message, bool isVoice)
			{
				if (state.IsBotBeingAddressed(playerWhoSentMessage, out PlayerControllerB lethalBotController3))
				{
					lethalBotAI.SendChatMessage("Alright, I'll head to the terminal and watch over the crew!");
					LethalBotManager.Instance.MissionControlPlayer = lethalBotController3;
					lethalBotAI.State = new MissionControlState(state);
				}
				return true;
			}));
			ChatCommandsManager.RegisterGlobalCommand(new ChatCommand("transfer loot", delegate(AIState state, LethalBotAI lethalBotAI, PlayerControllerB playerWhoSentMessage, string message, bool isVoice)
			{
				//IL_0022: 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)
				if (state.IsBotBeingAddressed(playerWhoSentMessage, out PlayerControllerB lethalBotController2))
				{
					lethalBotAI.SendChatMessage("I'll start transferring loot to the ship right away!");
					if (!LethalBotManager.Instance.LootTransferPlayers.Contains(NetworkBehaviourReference.op_Implicit((NetworkBehaviour)(object)lethalBotController2)))
					{
						LethalBotManager.Instance.AddPlayerToLootTransferListAndSync(NetworkBehaviourReference.op_Implicit((NetworkBehaviour)(object)lethalBotController2));
					}
					lethalBotAI.State = new TransferLootState(state);
				}
				return true;
			}));
			ChatCommandsManager.RegisterGlobalCommand(new ChatCommand("join group", delegate(AIState state, LethalBotAI lethalBotAI, PlayerControllerB playerWhoSentMessage, string message, bool isVoice)
			{
				if (state.IsBotBeingAddressed(playerWhoSentMessage, out PlayerControllerB lethalBotController))
				{
					int groupId = GroupManager.Instance.GetGroupId(lethalBotController);
					if (groupId != -1 && !GroupManager.Instance.ArePlayersInSameGroup(lethalBotController, playerWhoSentMessage))
					{
						lethalBotAI.SendChatMessage("Yes, you may join our group!");
						GroupManager.Instance.AddToGroupAndSync(groupId, playerWhoSentMessage);
					}
				}
				return true;
			}));
		}

		public static void RegisterSignalTranslatorCommands()
		{
			SignalTranslatorCommandsManager.RegisterGlobalCommand(new SignalTranslatorCommand("return", delegate(AIState state, LethalBotAI lethalBotAI, string message)
			{
				lethalBotAI.State = new ReturnToShipState(state);
				return true;
			}));
			SignalTranslatorCommandsManager.RegisterGlobalCommand(new SignalTranslatorCommand("jester", delegate(AIState state, LethalBotAI lethalBotAI, string message)
			{
				if (((EnemyAI)lethalBotAI).isOutside)
				{
					return true;
				}
				EnemyAI val = state.FindNearbyJester();
				if ((Object)(object)val == (Object)null)
				{
					return true;
				}
				lethalBotAI.State = new PanikState(state, val);
				return true;
			}));
		}

		public bool IsBotBeingAddressed(PlayerControllerB player, [NotNullWhen(true)] out PlayerControllerB? lethalBotController)
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			lethalBotController = null;
			if ((Object)(object)player == (Object)null)
			{
				return false;
			}
			RaycastHit[] array = (RaycastHit[])(object)new RaycastHit[3];
			Ray val = default(Ray);
			((Ray)(ref val))..ctor(((Component)player.gameplayCamera).transform.position, ((Component)player.gameplayCamera).transform.forward);
			int num = Physics.RaycastNonAlloc(val, array, 25f, StartOfRound.Instance.playersMask);
			for (int i = 0; i < num; i++)
			{
				RaycastHit val2 = array[i];
				if ((Object)(object)((RaycastHit)(ref val2)).collider == (Object)null || ((Component)((RaycastHit)(ref val2)).collider).tag != "Player")
				{
					continue;
				}
				lethalBotController = ((Component)((RaycastHit)(ref val2)).collider).gameObject.GetComponent<PlayerControllerB>();
				if (!((Object)(object)lethalBotController == (Object)null))
				{
					LethalBotAI lethalBotAIIfLocalIsOwner = LethalBotManager.Instance.GetLethalBotAIIfLocalIsOwner(lethalBotController);
					if (!((Object)(object)lethalBotAIIfLocalIsOwner == (Object)null) && !((Object)(object)lethalBotAIIfLocalIsOwner != (Object)(object)ai) && !lethalBotAIIfLocalIsOwner.IsSpawningAnimationRunning())
					{
						return true;
					}
				}
			}
			return false;
		}

		public virtual bool? ShouldBotCrouch()
		{
			if (npcController.Npc.isUnderwater)
			{
				return false;
			}
			if (ai.CheckProximityForEyelessDogs())
			{
				return true;
			}
			return null;
		}

		public virtual Vector3? SelectSubjectTargetPoint(LookAtTarget lookAtTarget, NetworkObject? subject, PlayerControllerB ourController)
		{
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)subject == (Object)null)
			{
				return null;
			}
			Vector3? val = null;
			EnemyAI val2 = default(EnemyAI);
			PlayerControllerB val3 = default(PlayerControllerB);
			return ((Component)subject).TryGetComponent<EnemyAI>(ref val2) ? ((!((Object)(object)val2.eye != (Object)null)) ? new Vector3?(((Component)val2).transform.position) : new Vector3?(((Component)val2.eye).transform.position)) : ((!((Component)subject).TryGetComponent<PlayerControllerB>(ref val3)) ? new Vector3?(((Component)subject).transform.position) : new Vector3?(((Component)val3.gameplayCamera).transform.position));
		}

		protected virtual EntranceTeleport? FindClosestEntrance(EntranceTeleport? entranceToAvoid, Vector3? shipPos = null)
		{
			HashSet<EntranceTeleport> entrancesToAvoid = ((!((Object)(object)entranceToAvoid != (Object)null)) ? null : new HashSet<EntranceTeleport> { entranceToAvoid });
			return FindClosestEntrance(shipPos, entrancesToAvoid);
		}

		protected virtual EntranceTeleport? FindClosestEntrance(Vector3? shipPos = null, HashSet<EntranceTeleport>? entrancesToAvoid = null)
		{
			//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_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0147: Unknown result type (might be due to invalid IL or missing references)
			//IL_014e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0154: Unknown result type (might be due to invalid IL or missing references)
			//IL_015c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0163: Unknown result type (might be due to invalid IL or missing references)
			bool flag = ShouldOnlyUseFrontEntrance();
			bool flag2 = false;
			bool isOutside = ((EnemyAI)ai).isOutside;
			EntranceTeleport result = null;
			float num = float.MaxValue;
			Vector3 valueOrDefault = shipPos.GetValueOrDefault();
			if (!shipPos.HasValue)
			{
				valueOrDefault = RoundManager.Instance.GetNavMeshPosition(StartOfRound.Instance.middleOfShipNode.position, default(NavMeshHit), 5f, -1);
				shipPos = valueOrDefault;
			}
			EntranceTeleport[] entrancesTeleportArray = LethalBotAI.EntrancesTeleportArray;
			foreach (EntranceTeleport val in entrancesTeleportArray)
			{
				if (entrancesToAvoid != null && entrancesToAvoid.Contains(val))
				{
					continue;
				}
				float pathDistance;
				if (isOutside && val.isEntranceToBuilding)
				{
					bool flag3 = IsFrontEntrance(val);
					if (flag && flag2 && !flag3)
					{
						break;
					}
					if (val.FindExitPoint() && !IsEntranceCoveredInQuickSand(val) && CanPathToEntrance(val, calculatePathDistance: true) && ((flag && !flag2 && flag3) || ((EnemyAI)ai).pathDistance < num))
					{
						result = val;
						num = ((EnemyAI)ai).pathDistance;
						flag2 = flag3;
					}
				}
				else if (!isOutside && !val.isEntranceToBuilding && val.FindExitPoint() && !IsEntranceCoveredInQuickSand(val) && LethalBotAI.IsValidPathToTarget(RoundManager.Instance.GetNavMeshPosition(val.exitScript.entrancePoint.position, default(NavMeshHit), 5f, -1), shipPos.Value, ((EnemyAI)ai).agent.areaMask, ref ((EnemyAI)ai).path1, calculatePathDistance: false, out pathDistance) && CanPathToEntrance(val, calculatePathDistance: true) && ((EnemyAI)ai).pathDistance < num)
				{
					result = val;
					num = ((EnemyAI)ai).pathDistance;
				}
			}
			return result;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool IsFrontEntrance([NotNullWhen(true)] EntranceTeleport? entrance)
		{
			if ((Object)(object)entrance != (Object)null)
			{
				return entrance.entranceId == 0;
			}
			return false;
		}

		protected bool IsEntranceCoveredInQuickSand(EntranceTeleport? entrance)
		{
			//IL_003b: 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)
			if (LethalBotAI.QuicksandArray == null || LethalBotAI.QuicksandArray.Length == 0)
			{
				return false;
			}
			if ((Object)(object)entrance != (Object)null)
			{
				return IsPositionCoveredInQuickSand(entrance.isEntranceToBuilding ? entrance.entrancePoint.position : entrance.exitScript.entrancePoint.position);
			}
			return false;
		}

		protected bool IsPositionCoveredInQuickSand(Vector3 targetPos, bool checkClosestNode = true)
		{
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0131: Unknown result type (might be due to invalid IL or missing references)
			//IL_0132: Unknown result type (might be due to invalid IL or missing references)
			//IL_0138: Unknown result type (might be due to invalid IL or missing references)
			//IL_013d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0142: Unknown result type (might be due to invalid IL or missing references)
			//IL_0146: Unknown result type (might be due to invalid IL or missing references)
			//IL_014b: Unknown result type (might be due to invalid IL or missing references)
			//IL_014f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: Unknown result type (might be due to invalid IL or missing references)
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_016b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0177: Unknown result type (might be due to invalid IL or missing references)
			//IL_017d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0197: Unknown result type (might be due to invalid IL or missing references)
			//IL_019c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_021c: Unknown result type (might be due to invalid IL or missing references)
			//IL_021e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0224: Unknown result type (might be due to invalid IL or missing references)
			//IL_0229: Unknown result type (might be due to invalid IL or missing references)
			//IL_022e: Unknown result type (might be due to invalid IL or missing references)
			//IL_023b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0240: Unknown result type (might be due to invalid IL or missing references)
			//IL_0244: Unknown result type (might be due to invalid IL or missing references)
			if (LethalBotAI.QuicksandArray == null || LethalBotAI.QuicksandArray.Length == 0)
			{
				return false;
			}
			RoundManager instance = RoundManager.Instance;
			float num = ((Component)npcController.Npc.gameplayCamera).transform.position.y - ((Component)npcController.Npc).transform.position.y;
			Vector3 navMeshPosition = instance.GetNavMeshPosition(targetPos, instance.navHit, 2.7f, ((EnemyAI)ai).agent.areaMask);
			float num2 = 2f;
			Plugin.LogDebug($"Testing quicksand safety for pos {targetPos}");
			QuicksandTrigger[] quicksandArray = LethalBotAI.QuicksandArray;
			foreach (QuicksandTrigger val in quicksandArray)
			{
				if (!((Behaviour)val).isActiveAndEnabled)
				{
					continue;
				}
				Collider component = ((Component)val).gameObject.GetComponent<Collider>();
				if ((Object)(object)component == (Object)null)
				{
					continue;
				}
				if (!val.isWater)
				{
					Plugin.LogDebug("This is quicksand!");
					Vector3 val2 = Physics.ClosestPoint(navMeshPosition, component, ((Component)component).transform.position, ((Component)component).transform.rotation);
					Vector3 val3 = val2 - navMeshPosition;
					if (((Vector3)(ref val3)).sqrMagnitude < num2 * num2)
					{
						Plugin.LogDebug("Segment intersects solid quicksand!");
						return true;
					}
					continue;
				}
				Plugin.LogDebug("This is water!");
				Vector3 val4 = navMeshPosition + Vector3.up * num;
				Bounds bounds = component.bounds;
				if (!((Bounds)(ref bounds)).Contains(val4))
				{
					continue;
				}
				if (!checkClosestNode)
				{
					Plugin.LogDebug("Simulated head intersects water!");
					return true;
				}
				Transform closestNode = instance.GetClosestNode(navMeshPosition, true);
				Vector3 navMeshPosition2 = instance.GetNavMeshPosition(closestNode.position, instance.navHit, 2.7f, ((EnemyAI)ai).agent.areaMask);
				float num3 = ((npcController.Npc.movementSpeed > 0f) ? npcController.Npc.movementSpeed : 4.5f);
				num3 /= npcController.Npc.carryWeight;
				float num4 = num3 / (2f * (1f * val.movementHinderance));
				float num5 = Vector3.Distance(navMeshPosition2, navMeshPosition) / num4;
				float num6 = num5 / 12f;
				float num7 = 1f - num6;
				val4 = navMeshPosition2 + Vector3.up * num;
				if (!(num7 <= 0f))
				{
					bounds = component.bounds;
					if (!((Bounds)(ref bounds)).Contains(val4))
					{
						continue;
					}
				}
				Plugin.LogDebug("Simulated head intersects water!");
				return true;
			}
			return false;
		}

		protected bool CanPathToEntrance(EntranceTeleport targetEntrance, bool calculatePathDistance = false)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			if (!ai.IsValidPathToTarget(targetEntrance.entrancePoint.position, calculatePathDistance))
			{
				if (IsFrontEntrance(targetEntrance) && !targetEntrance.isEntranceToBuilding && (Object)(object)LethalBotAI.ElevatorScript != (Object)null)
				{
					if (ai.IsValidPathToTarget(LethalBotAI.ElevatorScript.elevatorBottomPoint.position, calculatePathDistance))
					{
						return true;
					}
					return ai.IsInsideElevator;
				}
				return false;
			}
			return true;
		}

		public bool IsEntranceSafe(EntranceTeleport? entrance, bool useEntrancePoint = false)
		{
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)entrance == (Object)null || !entrance.FindExitPoint())
			{
				return false;
			}
			if (entranceSafetyCache.TryGetValue(entrance, out (bool, float) value) && Time.timeSinceLevelLoad - value.Item2 < 1f)
			{
				return value.Item1;
			}
			if ((Object)(object)FindNearbyJester() != (Object)null)
			{
				entranceSafetyCache[entrance] = (false, Time.timeSinceLevelLoad);
				return false;
			}
			Vector3 val = (useEntrancePoint ? entrance.entrancePoint.position : entrance.exitScript.entrancePoint.position);
			foreach (EnemyAI spawnedEnemy in RoundManager.Instance.SpawnedEnemies)
			{
				if (!spawnedEnemy.isEnemyDead && !(spawnedEnemy is LethalBotAI))
				{
					Vector3 val2 = ((Component)spawnedEnemy).transform.position - val;
					if (((Vector3)(ref val2)).sqrMagnitude < 59.289997f)
					{
						entranceSafetyCache[entrance] = (false, Time.timeSinceLevelLoad);
						return false;
					}
				}
			}
			entranceSafetyCache[entrance] = (true, Time.timeSinceLevelLoad);
			return true;
		}

		public static void ResetEntranceSafetyCache()
		{
			entranceSafetyCache.Clear();
		}

		protected virtual bool ShouldOnlyUseFrontEntrance()
		{
			//IL_001d: 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_0023: Unknown result type (might be due to invalid IL or missing references)
			TimeOfDay instance = TimeOfDay.Instance;
			if ((Object)(object)instance != (Object)null)
			{
				DayMode dayPhase = instance.GetDayPhase(instance.currentDayTime / instance.totalTime);
				if ((int)dayPhase == 0)
				{
					return true;
				}
			}
			return false;
		}

		public virtual bool ShouldReturnToShip()
		{
			if (Plugin.IsModFacilityMeltdownLoaded && HasMeltdownStarted())
			{
				return true;
			}
			TimeOfDay instance = TimeOfDay.Instance;
			if ((Object)(object)instance != (Object)null && (instance.normalizedTimeOfDay > SyncedEntry<float>.op_Implicit(Plugin.Config.ReturnToShipTime) || instance.votesForShipToLeaveEarly >= LethalBotManager.Instance.AllRealPlayersCount || instance.shipLeavingAlertCalled))
			{
				return true;
			}
			return false;
		}

		protected static bool HasMeltdownStarted()
		{
			if (Plugin.IsModFacilityMeltdownLoaded && MeltdownAPI.MeltdownStarted)
			{
				return true;
			}
			return false;
		}

		public virtual void UseHeldItem()
		{
			//IL_024c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0252: Unknown result type (might be due to invalid IL or missing references)
			bool flag = Plugin.IsModLethalPhonesLoaded;
			if (ai.CanUseHeldItem())
			{
				GrabbableObject heldItem = ai.HeldItem;
				WalkieTalkie val = (WalkieTalkie)(object)((heldItem is WalkieTalkie) ? heldItem : null);
				if (val != null)
				{
					if (ai.LethalBotIdentity.Voice.IsTalking())
					{
						flag = false;
						if (!((GrabbableObject)val).isBeingUsed && LethalBotAI.IsItemPowered((GrabbableObject?)(object)val))
						{
							((GrabbableObject)val).ItemInteractLeftRightOnClient(false);
						}
						else if (((GrabbableObject)val).isBeingUsed && !val.isHoldingButton)
						{
							((GrabbableObject)val).UseItemOnClient(true);
						}
					}
					else if (((GrabbableObject)val).isBeingUsed && val.isHoldingButton)
					{
						flag = false;
						((GrabbableObject)val).UseItemOnClient(false);
					}
				}
				else
				{
					ShotgunItem val2 = (ShotgunItem)(object)((heldItem is ShotgunItem) ? heldItem : null);
					if (val2 != null)
					{
						if (!val2.safetyOn)
						{
							flag = false;
							((GrabbableObject)val2).ItemInteractLeftRightOnClient(false);
						}
						else if (val2.shellsLoaded < 2 && ai.HasAmmoForWeapon((GrabbableObject?)(object)val2, spareOnly: true))
						{
							flag = false;
							((GrabbableObject)val2).ItemInteractLeftRightOnClient(true);
						}
					}
					else
					{
						TetraChemicalItem val3 = (TetraChemicalItem)(object)((heldItem is TetraChemicalItem) ? heldItem : null);
						if (val3 != null)
						{
							if (((GrabbableObject)val3).isBeingUsed)
							{
								flag = false;
								((GrabbableObject)val3).UseItemOnClient(false);
							}
						}
						else
						{
							FlashlightItem val4 = (FlashlightItem)(object)((heldItem is FlashlightItem) ? heldItem : null);
							if (val4 != null)
							{
								if (LethalBotAI.IsItemPowered((GrabbableObject?)(object)val4) && !ai.CheckProximityForEyelessDogs())
								{
									bool flag2 = false;
									float lightLevelAroundBot = ai.GetLightLevelAroundBot();
									if (lightLevelAroundBot < 1f)
									{
										if (!((GrabbableObject)val4).isBeingUsed)
										{
											flag2 = true;
										}
									}
									else if (((GrabbableObject)val4).isBeingUsed)
									{
										flag2 = true;
									}
									if (flag2)
									{
										flag = false;
										((GrabbableObject)val4).UseItemOnClient(true);
										if (((GrabbableObject)val4).itemProperties.holdButtonUse)
										{
											((GrabbableObject)val4).UseItemOnClient(false);
										}
									}
								}
							}
							else
							{
								CaveDwellerPhysicsProp val5 = (CaveDwellerPhysicsProp)(object)((heldItem is CaveDwellerPhysicsProp) ? heldItem : null);
								if (val5 != null)
								{
									CaveDwellerAI caveDwellerScript = val5.caveDwellerScript;
									if ((Object)(object)caveDwellerScript != (Object)null)
									{
										if (caveDwellerScript.babyCrying)
										{
											flag = false;
											if (caveDwellerScript.rockingBaby <= 0)
											{
												((GrabbableObject)val5).UseItemOnClient(true);
											}
										}
										else if (caveDwellerScript.rockingBaby > 0)
										{
											flag = false;
											((GrabbableObject)val5).UseItemOnClient(false);
										}
										else
										{
											BabyPlayerMemory babyMemoryOfPlayer_ReversePatch = CaveDwellerAIPatch.GetBabyMemoryOfPlayer_ReversePatch(caveDwellerScript, npcController.Npc);
											if ((babyMemoryOfPlayer_ReversePatch != null && babyMemoryOfPlayer_ReversePatch.likeMeter < 0.1f) || !Plugin.Config.AdvancedManeaterBabyAI.Value)
											{
												ai.DropItem();
											}
										}
									}
								}
								else
								{
									NoisemakerProp val6 = (NoisemakerProp)(object)((heldItem is NoisemakerProp) ? heldItem : null);
									if (val6 != null && (!useNoiseMakerCooldown.HasStarted() || useNoiseMakerCooldown.Elapsed()))
									{
										useNoiseMakerCooldown.Start(Random.Range(5f, 25f));
										if (!ai.CheckProximityForEyelessDogs())
										{
											((GrabbableObject)val6).UseItemOnClient(true);
											if (((GrabbableObject)val6).itemProperties.holdButtonUse)
											{
												((GrabbableObject)val6).UseItemOnClient(false);
											}
										}
									}
								}
							}
						}
					}
				}
			}
			if (flag)
			{
				UseLethalPhones();
			}
		}

		public void SelectBestItemFromInventory()
		{
			if (ai.CanSwitchItemSlot() && ai.TryFindItemInInventory(SelectBestItemFromInventoryFilter, SelectBetterItemFromInventory, out var objectSlot) && objectSlot != -1)
			{
				GrabbableObject itemAtSlot = ai.GetItemAtSlot(objectSlot);
				if (npcController.Npc.currentItemSlot != objectSlot || (Object)(object)ai.HeldItem != (Object)(object)itemAtSlot)
				{
					ai.SwitchItemSlotsAndSync(objectSlot);
				}
			}
		}

		protected virtual bool SelectBestItemFromInventoryFilter(GrabbableObject item)
		{
			if (!LethalBotAI.IsItemPowered(item))
			{
				return false;
			}
			if (item is WalkieTalkie)
			{
				if (ai.LethalBotIdentity.Voice.IsTalking())
				{
					return true;
				}
			}
			else
			{
				ShotgunItem val = (ShotgunItem)(object)((item is ShotgunItem) ? item : null);
				if (val != null)
				{
					if (!val.safetyOn || (val.shellsLoaded < 2 && ai.HasAmmoForWeapon((GrabbableObject?)(object)val, spareOnly: true)))
					{
						return true;
					}
				}
				else if (item is FlashlightItem && !ai.CheckProximityForEyelessDogs())
				{
					float lightLevelAroundBot = ai.GetLightLevelAroundBot();
					if (lightLevelAroundBot < 1f)
					{
						return true;
					}
					if (lightLevelAroundBot >= 1f && item.isBeingUsed)
					{
						return true;
					}
				}
			}
			return false;
		}

		protected virtual bool SelectBetterItemFromInventory(GrabbableObject currentBest, GrabbableObject candidate)
		{
			return GetItemPriority(candidate) > GetItemPriority(currentBest);
		}

		protected virtual int GetItemPriority(GrabbableObject item)
		{
			if (item is WalkieTalkie)
			{
				return 3;
			}
			if (item is ShotgunItem)
			{
				return 2;
			}
			if (item is FlashlightItem)
			{
				return 1;
			}
			return 0;
		}

		public virtual void UseLethalPhones()
		{
			if (!ai.IsLethalPhonesCoroutineRunning() && ai.HasIncomingCall())
			{
				ai.AcceptIncomingCall();
			}
			else if (!ai.AreWeInCall() && ai.IsPhoneEquipped())
			{
				ai.HangupPhone();
			}
		}

		public virtual void StopAllCoroutines()
		{
			if (ai.searchForScrap.searchInProgress)
			{
				ai.searchForScrap.StopSearch();
			}
			StopSafePathCoroutine();
			StopLookingAroundCoroutine();
			StopLethalBotInteraction();
		}

		[IteratorStateMachine(typeof(<findSafePathToTarget>d__72))]
		private IEnumerator findSafePathToTarget()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <findSafePathToTarget>d__72(0)
			{
				<>4__this = this
			};
		}

		protected virtual Vector3? GetDesiredSafePathPosition()
		{
			return null;
		}

		protected virtual bool ShouldIgnoreInitialDangerCheck()
		{
			return false;
		}

		protected void StartSafePathCoroutine()
		{
			if (safePathCoroutine == null)
			{
				safePathCoroutine = ((MonoBehaviour)ai).StartCoroutine(findSafePathToTarget());
			}
		}

		protected void StopSafePathCoroutine()
		{
			CancelAsyncPathfindToken();
			if (safePathCoroutine != null)
			{
				((MonoBehaviour)ai).StopCoroutine(safePathCoroutine);
				safePathCoroutine = null;
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public bool IsSafePathRunning()
		{
			return safePathCoroutine != null;
		}

		protected void CancelAsyncPathfindToken()
		{
			try
			{
				pathfindCancellationToken?.Cancel();
			}
			catch (ObjectDisposedException)
			{
			}
			finally
			{
				pathfindCancellationToken?.Dispose();
				pathfindCancellationToken = null;
			}
		}

		[IteratorStateMachine(typeof(<LookingAround>d__79))]
		protected virtual IEnumerator LookingAround()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <LookingAround>d__79(0)
			{
				<>4__this = this
			};
		}

		protected void StartLookingAroundCoroutine()
		{
			if (lookingAroundCoroutine == null)
			{
				lookingAroundCoroutine = ((MonoBehaviour)ai).StartCoroutine(LookingAround());
			}
		}

		protected void StopLookingAroundCoroutine()
		{
			if (lookingAroundCoroutine != null)
			{
				((MonoBehaviour)ai).StopCoroutine(lookingAroundCoroutine);
				lookingAroundCoroutine = null;
			}
		}

		public void StopLethalBotInteraction()
		{
			if (LethalBotInteraction != null)
			{
				if (!LethalBotInteraction.IsCompleted)
				{
					LethalBotInteraction.StopHoldInteractionOnTrigger();
				}
				LethalBotInteraction = null;
			}
		}

		protected virtual void ChangeBackToPreviousState()
		{
			if (previousAIState != null)
			{
				if ((Object)(object)previousStateUpdate.TargetItem != (Object)null)
				{
					previousAIState.TargetItem = previousStateUpdate.TargetItem;
				}
				if (previousStateUpdate.TargetLastKnownPosition.HasValue)
				{
					previousAIState.targetLastKnownPosition = previousStateUpdate.TargetLastKnownPosition;
				}
				ai.State = previousAIState;
			}
			else
			{
				Plugin.LogError($"Bot {npcController.Npc.playerClientId} ({npcController.Npc.playerUsername}) tried to change back to previous state, but it was null! This should never happen!");
				Plugin.LogWarning($"Bot {npcController.Npc.playerClientId} ({npcController.Npc.playerUsername}) will return to the ship instead!");
				ai.State = new ReturnToShipState(this);
			}
		}

		public virtual bool CheckAllowsTerminalUse()
		{
			return false;
		}

		public virtual EnumAIStates GetAIState()
		{
			return CurrentState;
		}

		public virtual string GetBillboardStateIndicator()
		{
			return string.Empty;
		}

		protected EnemyAI? FindNearbyJester()
		{
			RoundManager instance = RoundManager.Instance;
			foreach (EnemyAI spawnedEnemy in instance.SpawnedEnemies)
			{
				if (!((Object)(object)spawnedEnemy == (Object)null) && !spawnedEnemy.isEnemyDead && (!(spawnedEnemy.enemyType.enemyName != "Jester") || spawnedEnemy is JesterAI) && ai.GetFearRangeForEnemies(spawnedEnemy).HasValue)
				{
					return spawnedEnemy;
				}
			}
			return null;
		}

		protected virtual bool FindObject(GrabbableObject item)
		{
			int objectSlot;
			if (ai.IsGrabbableObjectInLoadout(item))
			{
				return ai.HasDuplicateLoadoutItems(item, out objectSlot);
			}
			return true;
		}

		protected virtual bool FindBetterObject(GrabbableObject currentBest, GrabbableObject candidate)
		{
			return false;
		}
	}
	public class LethalBotAI : EnemyAI
	{
		[CompilerGenerated]
		private sealed class <>c__DisplayClass265_0
		{
			public short phoneNumber;

			public NetworkBehaviour ourPhoneNetworkBehavior;

			internal void <callPlayerCoroutine>b__1(Component targetPhone)
			{
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				phoneNumber = ((PhoneBehavior)(PlayerPhone)targetPhone).phoneNumber;
			}

			internal bool <callPlayerCoroutine>b__2()
			{
				<>c__DisplayClass265_1 CS$<>8__locals0 = new <>c__DisplayClass265_1
				{
					armWeight = 0f
				};
				PhoneBehaviorPatch.TryWithPhone((Component)(object)ourPhoneNetworkBehavior, delegate(Component ourPhone)
				{
					CS$<>8__locals0.armWeight = ((RigConstraint<ChainIKConstraintJob, ChainIKConstraintData, ChainIKConstraintJobBinder<ChainIKConstraintData>>)(object)PhoneBehaviorPatch.GetServerLeftArmRig(ourPhone)).weight;
				});
				return CS$<>8__locals0.armWeight >= 1f;
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass265_1
		{
			public float armWeight;

			internal void <callPlayerCoroutine>b__4(Component ourPhone)
			{
				armWeight = ((RigConstraint<ChainIKConstraintJob, ChainIKConstraintData, ChainIKConstraintJobBinder<ChainIKConstraintData>>)(object)PhoneBehaviorPatch.GetServerLeftArmRig(ourPhone)).weight;
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass265_2
		{
			public char digit;

			internal void <callPlayerCoroutine>b__5(Component ourPhone)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				((PlayerPhone)ourPhone).DialNumber((int)(short)char.GetNumericValue(digit));
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass266_0
		{
			public NetworkBehaviour ourPhoneNetworkBehavior;

			internal bool <pickupCallCoroutine>b__1()
			{
				<>c__DisplayClass266_1 CS$<>8__locals0 = new <>c__DisplayClass266_1
				{
					armWeight = 0f
				};
				PhoneBehaviorPatch.TryWithPhone((Component)(object)ourPhoneNetworkBehavior, delegate(Component ourPhone)
				{
					//IL_0002: Unknown result type (might be due to invalid IL or missing references)
					//IL_000c: Expected O, but got Unknown
					CS$<>8__locals0.armWeight = ((RigConstraint<ChainIKConstraintJob, ChainIKConstraintData, ChainIKConstraintJobBinder<ChainIKConstraintData>>)(object)PhoneBehaviorPatch.GetServerLeftArmRig((object)(PlayerPhone)ourPhone)).weight;
				});
				return CS$<>8__locals0.armWeight >= 1f;
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass266_1
		{
			public float armWeight;

			internal void <pickupCallCoroutine>b__2(Component ourPhone)
			{
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: Expected O, but got Unknown
				armWeight = ((RigConstraint<ChainIKConstraintJob, ChainIKConstraintData, ChainIKConstraintJobBinder<ChainIKConstraintData>>)(object)PhoneBehaviorPatch.GetServerLeftArmRig((object)(PlayerPhone)ourPhone)).weight;
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass266_2
		{
			public NetworkVariable<short> activeCall;

			internal void <pickupCallCoroutine>b__3(Component ourPhoneComponent)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_0007: Expected O, but got Unknown
				//IL_001f: 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)
				PlayerPhone val = (PlayerPhone)ourPhoneComponent;
				PhoneNetworkHandler.Instance.AcceptIncomingCallServerRpc(activeCall.Value, ((NetworkBehaviour)val).NetworkObjectId, default(ServerRpcParams));
				((PhoneBehavior)val).StopRingingServerRpc();
				((PhoneBehavior)val).PlayPickupSoundServerRpc();
			}
		}

		[CompilerGenerated]
		private sealed class <CoroutineNoSpawnAnimation>d__292 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public LethalBotAI <>4__this;

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

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

			[DebuggerHidden]
			public <CoroutineNoSpawnAnimation>d__292(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_002e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0038: Expected O, but got Unknown
				//IL_0049: Unknown result type (might be due to invalid IL or missing references)
				//IL_0053: Expected O, but got Unknown
				int num = <>1__state;
				LethalBotAI lethalBotAI = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitForEndOfFrame();
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<>2__current = (object)new WaitForEndOfFrame();
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					<>2__current = null;
					<>1__state = 3;
					return true;
				case 3:
					<>1__state = -1;
					((MonoBehaviour)lethalBotAI).StartCoroutine(lethalBotAI.Wait2EndOfFrameToRefreshBillBoard());
					if (!((NetworkBehaviour)lethalBotAI).IsOwner)
					{
						lethalBotAI.spawnAnimationCoroutine = null;
						return false;
					}
					lethalBotAI.State = lethalBotAI.GetDesiredAIState();
					lethalBotAI.spawnAnimationCoroutine = null;
					return false;
				}
			}

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

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

		[CompilerGenerated]
		private sealed class <CoroutineOnlyPlayerSpawnAnimation>d__293 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public LethalBotAI <>4__this;

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

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

			[DebuggerHidden]
			public <CoroutineOnlyPlayerSpawnAnimation>d__293(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0036: Unknown result type (might be due to invalid IL or missing references)
				//IL_0040: Expected O, but got Unknown
				//IL_0051: Unknown result type (might be due to invalid IL or missing references)
				//IL_005b: Expected O, but got Unknown
				//IL_0129: Unknown result type (might be due to invalid IL or missing references)
				//IL_0133: Expected O, but got Unknown
				//IL_0090: Unknown result type (might be due to invalid IL or missing references)
				//IL_009a: Expected O, but got Unknown
				int num = <>1__state;
				LethalBotAI lethalBotAI = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitForEndOfFrame();
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<>2__current = (object)new WaitForEndOfFrame();
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					<>2__current = null;
					<>1__state = 3;
					return true;
				case 3:
					<>1__state = -1;
					if (!((NetworkBehaviour)lethalBotAI).IsOwner)
					{
						<>2__current = (object)new WaitForSeconds(3f);
						<>1__state = 4;
						return true;
					}
					lethalBotAI.UpdateLethalBotSpecialAnimationValue(specialAnimation: true, 0f, climbingLadder: false);
					lethalBotAI.NpcController.Npc.inSpecialInteractAnimation = true;
					lethalBotAI.NpcController.Npc.playerBodyAnimator.ResetTrigger("SpawnPlayer");
					lethalBotAI.NpcController.Npc.playerBodyAnimator.SetTrigger("SpawnPlayer");
					<>2__current = (object)new WaitForSeconds(3f);
					<>1__state = 5;
					return true;
				case 4:
					<>1__state = -1;
					((MonoBehaviour)lethalBotAI).StartCoroutine(lethalBotAI.Wait2EndOfFrameToRefreshBillBoard());
					lethalBotAI.NpcController.Npc.inSpecialInteractAnimation = false;
					lethalBotAI.spawnAnimationCoroutine = null;
					return false;
				case 5:
					<>1__state = -1;
					((MonoBehaviour)lethalBotAI).StartCoroutine(lethalBotAI.Wait2EndOfFrameToRefreshBillBoard());
					lethalBotAI.NpcController.Npc.inSpecialInteractAnimation = false;
					lethalBotAI.UpdateLethalBotSpecialAnimationValue(specialAnimation: false, 0f, climbingLadder: false);
					lethalBotAI.State = lethalBotAI.GetDesiredAIState();
					lethalBotAI.spawnAnimationCoroutine = null;
					return false;
				}
			}

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

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

		[CompilerGenerated]
		private sealed class <GrabAnimationCoroutine>d__238 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public LethalBotAI <>4__this;

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

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

			[DebuggerHidden]
			public <GrabAnimationCoroutine>d__238(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_005d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0067: Expected O, but got Unknown
				int num = <>1__state;
				LethalBotAI lethalBotAI = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					if (!lethalBotAI.AreHandsFree())
					{
						float num2 = ((lethalBotAI.HeldItem.itemProperties.grabAnimationTime > 0f) ? lethalBotAI.HeldItem.itemProperties.grabAnimationTime : 0.4f);
						<>2__current = (object)new WaitForSeconds(num2 - 0.2f);
						<>1__state = 1;
						return true;
					}
					lethalBotAI.NpcController.Npc.playerBodyAnimator.SetBool("GrabInvalidated", true);
					lethalBotAI.NpcController.Npc.isGrabbingObjectAnimation = false;
					break;
				case 1:
					<>1__state = -1;
					lethalBotAI.NpcController.Npc.playerBodyAnimator.SetBool("GrabValidated", true);
					lethalBotAI.NpcController.Npc.isGrabbingObjectAnimation = false;
					break;
				}
				return false;
			}

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

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

		[CompilerGenerated]
		private sealed class <Wait2EndOfFrameToRefreshBillBoard>d__326 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public LethalBotAI <>4__this;

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

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

			[DebuggerHidden]
			public <Wait2EndOfFrameToRefreshBillBoard>d__326(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_002a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0034: Expected O, but got Unknown
				//IL_0045: Unknown result type (might be due to invalid IL or missing references)
				//IL_004f: Expected O, but got Unknown
				int num = <>1__state;
				LethalBotAI lethalBotAI = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitForEndOfFrame();
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<>2__current = (object)new WaitForEndOfFrame();
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					lethalBotAI.NpcController.RefreshBillBoardPosition();
					return false;
				}
			}

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

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

		[CompilerGenerated]
		private sealed class <autoTraverseOffMeshLink>d__143 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public LethalBotAI <>4__this;

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

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

			[DebuggerHidden]
			public <autoTraverseOffMeshLink>d__143(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0059: Unknown result type (might be due to invalid IL or missing references)
				//IL_0063: Expected O, but got Unknown
				int num = <>1__state;
				LethalBotAI CS$<>8__locals0 = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					((EnemyAI)CS$<>8__locals0).agent.autoTraverseOffMeshLink = true;
					<>2__current = null;
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<>2__current = (object)new WaitUntil((Func<bool>)(() => !((EnemyAI)CS$<>8__locals0).agent.isOnOffMeshLink));
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					((EnemyAI)CS$<>8__locals0).agent.autoTraverseOffMeshLink = false;
					CS$<>8__locals0.offMeshLinkCoroutine = null;
					return false;
				}
			}

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

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

		[CompilerGenerated]
		private sealed class <callPlayerCoroutine>d__265 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public NetworkBehaviour ourPhoneNetworkBehavior;

			private <>c__DisplayClass265_0 <>8__1;

			public LethalBotAI <>4__this;

			public NetworkBehaviour targetPhoneNetworkBehavior;

			private string <>7__wrap1;

			private int <>7__wrap2;

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

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

			[DebuggerHidden]
			public <callPlayerCoroutine>d__265(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>8__1 = null;
				<>7__wrap1 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f4: Expected O, but got Unknown
				//IL_0173: Unknown result type (might be due to invalid IL or missing references)
				//IL_017d: Expected O, but got Unknown
				int num = <>1__state;
				LethalBotAI lethalBotAI = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>8__1 = new <>c__DisplayClass265_0();
					<>8__1.ourPhoneNetworkBehavior = ourPhoneNetworkBehavior;
					<>2__current = null;
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					PhoneBehaviorPatch.TryWithPhone((Component)(object)<>8__1.ourPhoneNetworkBehavior, delegate(Component ourPhoneComponent)
					{
						//IL_0001: Unknown result type (might be due to invalid IL or missing references)
						//IL_0007: Expected O, but got Unknown
						PlayerPhone val = (PlayerPhone)ourPhoneComponent;
						if (((RigConstraint<ChainIKConstraintJob, ChainIKConstraintData, ChainIKConstraintJobBinder<ChainIKConstraintData>>)(object)PhoneBehaviorPatch.GetServerLeftArmRig(val)).weight < 1f)
						{
							val.ToggleServerPhoneModelServerRpc(true);
						}
					});
					lethalBotAI.HangupPhone();
					<>8__1.phoneNumber = 0;
					PhoneBehaviorPatch.TryWithPhone((Component)(object)targetPhoneNetworkBehavior, delegate(Component targetPhone)
					{
						//IL_0002: Unknown result type (might be due to invalid IL or missing references)
						<>8__1.phoneNumber = ((PhoneBehavior)(PlayerPhone)targetPhone).phoneNumber;
					});
					<>2__current = null;
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					<>2__current = (object)new WaitUntil((Func<bool>)delegate
					{
						<>c__DisplayClass265_1 CS$<>8__locals1 = new <>c__DisplayClass265_1
						{
							armWeight = 0f
						};
						PhoneBehaviorPatch.TryWithPhone((Component)(object)<>8__1.ourPhoneNetworkBehavior, delegate(Component ourPhone)
						{
							CS$<>8__locals1.armWeight = ((RigConstraint<ChainIKConstraintJob, ChainIKConstraintData, ChainIKConstraintJobBinder<ChainIKConstraintData>>)(object)PhoneBehaviorPatch.GetServerLeftArmRig(ourPhone)).weight;
						});
						return CS$<>8__locals1.armWeight >= 1f;
					});
					<>1__state = 3;
					return true;
				case 3:
				{
					<>1__state = -1;
					string text = <>8__1.phoneNumber.ToString("D4");
					<>7__wrap1 = text;
					<>7__wrap2 = 0;
					break;
				}
				case 4:
					<>1__state = -1;
					<>7__wrap2++;
					break;
				}
				if (<>7__wrap2 < <>7__wrap1.Length)
				{
					<>c__DisplayClass265_2 CS$<>8__locals0 = new <>c__DisplayClass265_2
					{
						digit = <>7__wrap1[<>7__wrap2]
					};
					PhoneBehaviorPatch.TryWithPhone((Component)(object)<>8__1.ourPhoneNetworkBehavior, delegate(Component ourPhone)
					{
						//IL_0001: Unknown result type (might be due to invalid IL or missing references)
						((PlayerPhone)ourPhone).DialNumber((int)(short)char.GetNumericValue(CS$<>8__locals0.digit));
					});
					<>2__current = (object)new WaitForSeconds(Random.Range(0.1f, 0.3f));
					<>1__state = 4;
					return true;
				}
				<>7__wrap1 = null;
				PhoneBehaviorPatch.TryWithPhone((Component)(object)<>8__1.ourPhoneNetworkBehavior, delegate(Component ourPhone)
				{
					//IL_0001: Unknown result type (might be due to invalid IL or missing references)
					((PlayerPhone)ourPhone).CallDialedNumber();
				});
				lethalBotAI.StopLethalPhonesCoroutine();
				return false;
			}

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

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

		[CompilerGenerated]
		private sealed class <offMeshLinkParabola>d__145 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public NavMeshAgent agent;

			public LethalBotAI <>4__this;

			public float height;

			private OffMeshLinkData <data>5__2;

			private Vector3 <startPos>5__3;

			private Vector3 <endPos>5__4;

			private float <normalizedTime>5__5;

			private float <duration>5__6;

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

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

			[DebuggerHidden]
			public <offMeshLinkParabola>d__145(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0028: Unknown result type (might be due to invalid IL or missing references)
				//IL_002d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0039: Unknown result type (might be due to invalid IL or missing references)
				//IL_003e: Unknown result type (might be due to invalid IL or missing references)
				//IL_004a: Unknown result type (might be due to invalid IL or missing references)
				//IL_004f: Unknown result type (might be due to invalid IL or missing references)
				//IL_005f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0064: Unknown result type (might be due to invalid IL or missing references)
				//IL_0069: Unknown result type (might be due to invalid IL or missing references)
				//IL_007a: Unknown result type (might be due to invalid IL or missing references)
				//IL_007f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0084: Unknown result type (might be due to invalid IL or missing references)
				//IL_0089: Unknown result type (might be due to invalid IL or missing references)
				//IL_008b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0090: Unknown result type (might be due to invalid IL or missing references)
				//IL_0095: Unknown result type (might be due to invalid IL or missing references)
				//IL_009a: Unknown result type (might be due to invalid IL or missing references)
				//IL_009b: Unknown result type (might be due to invalid IL or missing references)
				//IL_009c: Unknown result type (might be due to invalid IL or missing references)
				//IL_01f8: Unknown result type (might be due to invalid IL or missing references)
				//IL_020e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0142: Unknown result type (might be due to invalid IL or missing references)
				//IL_0148: Unknown result type (might be due to invalid IL or missing references)
				//IL_0153: Unknown result type (might be due to invalid IL or missing references)
				//IL_015a: Unknown result type (might be due to invalid IL or missing references)
				//IL_015f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0164: Unknown result type (might be due to invalid IL or missing references)
				//IL_017f: Unknown result type (might be due to invalid IL or missing references)
				int num = <>1__state;
				LethalBotAI lethalBotAI = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
				{
					<>1__state = -1;
					<data>5__2 = agent.currentOffMeshLinkData;
					<startPos>5__3 = ((Component)lethalBotAI).transform.position;
					<endPos>5__4 = ((OffMeshLinkData)(ref <data>5__2)).endPos + Vector3.up * agent.baseOffset;
					<normalizedTime>5__5 = 0f;
					Vector3 val = Vector3.ProjectOnPlane(<startPos>5__3, Vector3.up);
					Vector3 val2 = Vector3.ProjectOnPlane(<endPos>5__4, Vector3.up);
					float num2 = Vector3.Distance(val, val2);
					<duration>5__6 = num2 / agent.speed;
					Plugin.LogDebug($"Beginning off mesh link movement. {((OffMeshLinkData)(ref <data>5__2)).valid}; {((OffMeshLinkData)(ref <data>5__2)).activated}; {((NetworkBehaviour)lethalBotAI).IsOwner}");
					break;
				}
				case 1:
					<>1__state = -1;
					break;
				}
				if (<normalizedTime>5__5 < 1f && ((OffMeshLinkData)(ref <data>5__2)).valid && ((OffMeshLinkData)(ref <data>5__2)).activated && ((NetworkBehaviour)lethalBotAI).IsOwner)
				{
					float num3 = height * 4f * (<normalizedTime>5__5 - <normalizedTime>5__5 * <normalizedTime>5__5);
					Plugin.LogDebug($"Moving on off mesh link; time: {<normalizedTime>5__5}; y: {num3}");
					((Component)lethalBotAI).transform.position = Vector3.Lerp(<startPos>5__3, <endPos>5__4, <normalizedTime>5__5) + num3 * Vector3.up;
					((Component)agent).transform.position = ((Component)lethalBotAI).transform.position;
					<normalizedTime>5__5 += Time.deltaTime / <duration>5__6;
					<>2__current = null;
					<>1__state = 1;
					return true;
				}
				agent.CompleteOffMeshLink();
				lethalBotAI.TeleportAgentAIAndBody(<endPos>5__4);
				Plugin.LogDebug($"Completed off mesh link without interruption, position: {((Component)lethalBotAI).transform.position}");
				lethalBotAI.offMeshLinkCoroutine = null;
				return false;
			}

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

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

		[CompilerGenerated]
		private sealed class <pickupCallCoroutine>d__266 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public NetworkBehaviour ourPhoneNetworkBehavior;

			private <>c__DisplayClass266_0 <>8__1;

			public LethalBotAI <>4__this;

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

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

			[DebuggerHidden]
			public <pickupCallCoroutine>d__266(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>8__1 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c6: Expected O, but got Unknown
				//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f0: Expected O, but got Unknown
				//IL_01b8: Unknown result type (might be due to invalid IL or missing references)
				//IL_01be: Unknown result type (might be due to invalid IL or missing references)
				int num = <>1__state;
				LethalBotAI lethalBotAI = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>8__1 = new <>c__DisplayClass266_0();
					<>8__1.ourPhoneNetworkBehavior = ourPhoneNetworkBehavior;
					<>2__current = null;
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					PhoneBehaviorPatch.TryWithPhone((Component)(object)<>8__1.ourPhoneNetworkBehavior, delegate(Component ourPhoneComponent)
					{
						//IL_0001: Unknown result type (might be due to invalid IL or missing references)
						//IL_0007: Expected O, but got Unknown
						PlayerPhone val4 = (PlayerPhone)ourPhoneComponent;
						if (((RigConstraint<ChainIKConstraintJob, ChainIKConstraintData, ChainIKConstraintJobBinder<ChainIKConstraintData>>)(object)PhoneBehaviorPatch.GetServerLeftArmRig(val4)).weight < 1f)
						{
							val4.ToggleServerPhoneModelServerRpc(true);
						}
					});
					<>2__current = null;
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					<>2__current = (object)new WaitUntil((Func<bool>)delegate
					{
						<>c__DisplayClass266_1 CS$<>8__locals1 = new <>c__DisplayClass266_1
						{
							armWeight = 0f
						};
						PhoneBehaviorPatch.TryWithPhone((Component)(object)<>8__1.ourPhoneNetworkBehavior, delegate(Component ourPhone)
						{
							//IL_0002: Unknown result type (might be due to invalid IL or missing references)
							//IL_000c: Expected O, but got Unknown
							CS$<>8__locals1.armWeight = ((RigConstraint<ChainIKConstraintJob, ChainIKConstraintData, ChainIKConstraintJobBinder<ChainIKConstraintData>>)(object)PhoneBehaviorPatch.GetServerLeftArmRig((object)(PlayerPhone)ourPhone)).weight;
						});
						return CS$<>8__locals1.armWeight >= 1f;
					});
					<>1__state = 3;
					return true;
				case 3:
					<>1__state = -1;
					<>2__current = (object)new WaitForSeconds(Random.Range(0.5f, 1.5f));
					<>1__state = 4;
					return true;
				case 4:
				{
					<>1__state = -1;
					NetworkVariable<short> val = (NetworkVariable<short>)PhoneBehaviorPatch.incomingCall.GetValue(<>8__1.ourPhoneNetworkBehavior);
					NetworkVariable<ulong> val2 = (NetworkVariable<ulong>)PhoneBehaviorPatch.incomingCaller.GetValue(<>8__1.ourPhoneNetworkBehavior);
					if (val.Value != -1)
					{
						<>c__DisplayClass266_2 CS$<>8__locals0 = new <>c__DisplayClass266_2
						{
							activeCall = (NetworkVariable<short>)PhoneBehaviorPatch.activeCall.GetValue(<>8__1.ourPhoneNetworkBehavior)
						};
						NetworkVariable<ulong> val3 = (NetworkVariable<ulong>)PhoneBehaviorPatch.activeCaller.GetValue(<>8__1.ourPhoneNetworkBehavior);
						if (CS$<>8__locals0.activeCall.Value != -1)
						{
							PhoneNetworkHandler.Instance.HangUpCallServerRpc(CS$<>8__locals0.activeCall.Value, <>8__1.ourPhoneNetworkBehavior.NetworkObjectId, default(ServerRpcParams));
						}
						CS$<>8__locals0.activeCall.Value = val.Value;
						val3.Value = val2.Value;
						val.Value = -1;
						PhoneBehaviorPatch.TryWithPhone((Component)(object)<>8__1.ourPhoneNetworkBehavior, delegate(Component ourPhoneComponent)
						{
							//IL_0001: Unknown result type (might be due to invalid IL or missing references)
							//IL_0007: Expected O, but got Unknown
							//IL_001f: 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)
							PlayerPhone val5 = (PlayerPhone)ourPhoneComponent;
							PhoneNetworkHandler.Instance.AcceptIncomingCallServerRpc(CS$<>8__locals0.activeCall.Value, ((NetworkBehaviour)val5).NetworkObjectId, default(ServerRpcParams));
							((PhoneBehavior)val5).StopRingingServerRpc();
							((PhoneBehavior)val5).PlayPickupSoundServerRpc();
						});
					}
					lethalBotAI.StopLethalPhonesCoroutine();
					return false;
				}
				}
			}

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

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

		[CompilerGenerated]
		private sealed class <pullLeverCoroutine>d__298 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public LethalBotAI <>4__this;

			public InteractTrigger leverTrigger;

			public StartMatchLever startMatchLever;

			private PlayerControllerB <localPlayerController>5__2;

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

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

			[DebuggerHidden]
			public <pullLeverCoroutine>d__298(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<localPlayerController>5__2 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
				//IL_011c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0126: Expected O, but got Unknown
				int num = <>1__state;
				LethalBotAI lethalBotAI = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<localPlayerController>5__2 = lethalBotAI.NpcController.Npc;
					InteractTriggerPatch.UpdateUsedByPlayerServerRpc_ReversePatch(leverTrigger, (int)<localPlayerController>5__2.playerClientId);
					lethalBotAI.DoLeverAnimation(startMatchLever);
					leverTrigger.isPlayingSpecialAnimation = true;
					<localPlayerController>5__2.inSpecialInteractAnimation = true;
					<localPlayerController>5__2.currentTriggerInAnimationWith = leverTrigger;
					<localPlayerController>5__2.playerBodyAnimator.ResetTrigger(leverTrigger.animationString);
					<localPlayerController>5__2.playerBodyAnimator.SetTrigger(leverTrigger.animationString);
					<localPlayerController>5__2.Crouch(false);
					<localPlayerController>5__2.UpdateSpecialAnimationValue(true, (short)leverTrigger.playerPositionNode.eulerAngles.y, 0f, false);
					if (Object.op_Implicit((Object)(object)leverTrigger.overridePlayerParent))
					{
						<localPlayerController>5__2.overridePhysicsParent = leverTrigger.overridePlayerParent;
					}
					<>2__current = (object)new WaitForSeconds(leverTrigger.animationWaitTime);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					InteractTriggerPatch.StopUsingServerRpc_ReversePatch(leverTrigger, (int)<localPlayerController>5__2.playerClientId);
					leverTrigger.isPlayingSpecialAnimation = false;
					<localPlayerController>5__2.inSpecialInteractAnimation = false;
					if (Object.op_Implicit((Object)(object)leverTrigger.overridePlayerParent) && (Object)(object)<localPlayerController>5__2.overridePhysicsParent == (Object)(object)leverTrigger.overridePlayerParent)
					{
						<localPlayerController>5__2.overridePhysicsParent = null;
					}
					<localPlayerController>5__2.currentTriggerInAnimationWith = null;
					leverTrigger.currentCooldownValue = leverTrigger.cooldownTime;
					lethalBotAI.DoPullLever(startMatchLever);
					return false;
				}
			}

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

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

		[CompilerGenerated]
		private sealed class <useItemCharger>d__306 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public LethalBotAI <>4__this;

			public InteractTrigger itemChargerTrigger;

			public ItemCharger itemCharger;

			public GrabbableObject itemToCharge;

			private PlayerControllerB <localPlayerController>5__2;

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

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

			[DebuggerHidden]
			public <useItemCharger>d__306(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<localPlayerController>5__2 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
				//IL_0122: Unknown result type (might be due to invalid IL or missing references)
				//IL_012c: Expected O, but got Unknown
				//IL_01c5: Unknown result type (might be due to invalid IL or missing references)
				//IL_01cf: Expected O, but got Unknown
				//IL_016b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0175: Expected O, but got Unknown
				//IL_019d: Unknown result type (might be due to invalid IL or missing references)
				int num = <>1__state;
				LethalBotAI lethalBotAI = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<localPlayerController>5__2 = lethalBotAI.NpcController.Npc;
					InteractTriggerPatch.UpdateUsedByPlayerServerRpc_ReversePatch(itemChargerTrigger, (int)<localPlayerController>5__2.playerClientId);
					itemChargerTrigger.isPlayingSpecialAnimation = true;
					<localPlayerController>5__2.inSpecialInteractAnimation = true;
					<localPlayerController>5__2.currentTriggerInAnimationWith = itemChargerTrigger;
					<localPlayerController>5__2.playerBodyAnimator.ResetTrigger(itemChargerTrigger.animationString);
					<localPlayerController>5__2.playerBodyAnimator.SetTrigger(itemChargerTrigger.animationString);
					<localPlayerController>5__2.Crouch(false);
					<localPlayerController>5__2.UpdateSpecialAnimationValue(true, (short)itemChargerTrigger.playerPositionNode.eulerAngles.y, 0f, false);
					if (Object.op_Implicit((Object)(object)itemChargerTrigger.overridePlayerParent))
					{
						<localPlayerController>5__2.overridePhysicsParent = itemChargerTrigger.overridePlayerParent;
					}
					itemCharger.zapAudio.Play();
					<>2__current = (object)new WaitForSeconds(0.75f);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					itemCharger.chargeStationAnimator.SetTrigger("zap");
					if ((Object)(object)itemToCharge != (Object)null)
					{
						itemToCharge.insertedBattery = new Battery(false, 1f);
						if (((NetworkBehaviour)itemToCharge).IsOwner)
						{
							itemToCharge.SyncBatteryServerRpc(100);
						}
						else
						{
							lethalBotAI.SyncBatteryLethalBotServerRpc(NetworkObjectReference.op_Implicit(((NetworkBehaviour)itemToCharge).NetworkObject), 100);
						}
					}
					<>2__current = (object)new WaitForSeconds(Mathf.Max(itemChargerTrigger.animationWaitTime - 0.75f, 0f));
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					InteractTriggerPatch.StopUsingServerRpc_ReversePatch(itemChargerTrigger, (int)<localPlayerController>5__2.playerClientId);
					itemChargerTrigger.isPlayingSpecialAnimation = false;
					<localPlayerController>5__2.inSpecialInteractAnimation = false;
					if (Object.op_Implicit((Object)(object)itemChargerTrigger.overridePlayerParent) && (Object)(object)<localPlayerController>5__2.overridePhysicsParent == (Object)(object)itemChargerTrigger.overridePlayerParent)
					{
						<localPlayerController>5__2.overridePhysicsParent = null;
					}
					<localPlayerController>5__2.currentTriggerInAnimationWith = null;
					itemChargerTrigger.currentCooldownValue = itemChargerTrigger.cooldownTime;
					itemChargerTrigger.StopSpecialAnimation();
					return false;
				}
			}

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

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

		[CompilerGenerated]
		private sealed class <waitUntilFrameEndToSetActive>d__275 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public Terminal ourTerminal;

			public bool active;

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

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

			[DebuggerHidden]
			public <waitUntilFrameEndToSetActive>d__275(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0018: Unknown result type (might be due to invalid IL or missing references)
				//IL_0022: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitForEndOfFrame();
					<>1__state = 1;
					return true;
				case 1:
				{
					<>1__state = -1;
					Terminal obj = ourTerminal;
					if (obj != null)
					{
						((Component)obj.terminalUIScreen).gameObject.SetActive(active);
					}
					return false;
				}
				}
			}

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

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

		public static Dictionary<GrabbableObject, float> DictJustDroppedItems = new Dictionary<GrabbableObject, float>();

		public Dictionary<MaskedPlayerEnemy, bool> DictKnownMasked = new Dictionary<MaskedPlayerEnemy, bool>();

		private AIState _state;

		public NpcController NpcController;

		public LethalBotIdentity LethalBotIdentity;

		public AudioSource LethalBotVoice;

		[CompilerGenerated]
		private DunGenTileTracker <DunGenTileTracker>k__BackingField;

		public GrabbableObject? HeldItem;

		public Collider LethalBotBodyCollider;

		public int BotId = -1;

		public int MaxHealth = 100;

		public float TimeSinceTeleporting;

		internal bool choseRandomFlyDirForPlayer;

		internal Vector3 randomFlyDir;

		public TimedTouchingGroundCheck IsTouchingGroundTimedCheck;

		private EnumStateControllerMovement StateControllerMovement;

		private static InteractTrigger[] laddersInteractTrigger = null;

		private static DoorLock[] doorLocksArray = null;

		[CompilerGenerated]
		private static ShipTeleporter? <InverseTeleporter>k__BackingField;

		[CompilerGenerated]
		private static DissonanceComms? <DissonanceComms>k__BackingField;

		private float timerElevatorCooldown;

		private static float pressElevatorButtonCooldown;

		private Dictionary<Collider, BridgeTrigger> dictColliderToBridge;

		public LethalBotSearchRoutine searchForScrap;

		private Coroutine grabObjectCoroutine;

		internal Coroutine? spawnAnimationCoroutine;

		public Coroutine? useLadderCoroutine;

		private Coroutine? offMeshLinkCoroutine;

		internal Coroutine? useInteractTriggerCoroutine;

		private Coroutine? lethalPhonesCoroutine;

		public NetworkVariable<float> FearLevel = new NetworkVariable<float>(0f, (NetworkVariableReadPermission)0, (NetworkVariableWritePermission)1);

		public NetworkVariable<bool> FearLevelIncreasing = new NetworkVariable<bool>(false, (NetworkVariableReadPermission)0, (NetworkVariableWritePermission)1);

		public NetworkVariable<LethalBotInfection> BotInfectionData = new NetworkVariable<LethalBotInfection>((LethalBotInfection)null, (NetworkVariableReadPermission)0, (NetworkVariableWritePermission)1);

		public NetworkVariable<float> HealInfectionLevel = new NetworkVariable<float>(0f, (NetworkVariableReadPermission)0, (NetworkVariableWritePermission)1);

		private string stateIndicatorServer = string.Empty;

		private Vector3 previousWantedDestination;

		private bool hasDestinationChanged = true;

		private float updateDestinationIntervalLethalBotAI;

		private CountdownTimer updateDestinationTimer = new CountdownTimer();

		private float healthRegenerateTimerMax;

		private float timerCheckDoor;

		private float timerCheckLockedDoor;

		private float nextExposedToEnemyTimer;

		private bool _areWeExposed;

		private float nextEyelessdogCheckTimer;

		private bool _isEyelessDogInPromimity;

		public LineRendererUtil LineRendererUtil;

		private float stuckTimer;

		private static readonly FieldRef<NutcrackerEnemyAI, bool> nutcrackerIsInspecting = (FieldRef<NutcrackerEnemyAI, bool>)(object)AccessTools.FieldRefAccess<bool>(typeof(NutcrackerEnemyAI), "isInspecting");

		private static readonly FieldRef<DoorLock, bool> isDoorOpenedField = (FieldRef<DoorLock, bool>)(object)AccessTools.FieldRefAccess<bool>(typeof(DoorLock), "isDoorOpened");

		private static readonly FieldRef<ExtensionLadderItem, bool> extensionLadderItemLadderActivated = (FieldRef<ExtensionLadderItem, bool>)(object)AccessTools.FieldRefAccess<bool>(typeof(ExtensionLadderItem), "ladderActivated");

		private static readonly Action<StartMatchLever> setStartingShipEffectsMethod = AccessTools.MethodDelegate<Action<StartMatchLever>>(AccessTools.Method(typeof(StartMatchLever), "SetStartingShipEffects", (Type[])null, (Type[])null), (object)null, true);

		private static readonly Action<StartMatchLever, bool> pullLeverAnimMethod = AccessTools.MethodDelegate<Action<StartMatchLever, bool>>(AccessTools.Method(typeof(StartMatchLever), "PullLeverAnim", (Type[])null, (Type[])null), (object)null, true);

		private static readonly FieldRef<StartMatchLever, bool> clientSentRPCField = (FieldRef<StartMatchLever, bool>)(object)AccessTools.FieldRefAccess<bool>(typeof(StartMatchLever), "clientSentRPC");

		public AIState State
		{
			get
			{
				return _state;
			}
			set
			{
				AIState state = _state;
				if (value == null)
				{
					throw new NullReferenceException("LethalBot " + NpcController.Npc.playerUsername + " tried to set a null state!");
				}
				if (state != null)
				{
					Plugin.LogDebug($"LethalBot {NpcController.Npc.playerUsername} change from {state.GetAIState()} to {value.GetAIState()}!");
					state.OnExitState(value);
					state.StopAllCoroutines();
				}
				_state = value;
				value.OnEnterState();
			}
		}

		public DunGenTileTracker DunGenTileTracker
		{
			get
			{
				if ((Object)(object)<DunGenTileTracker>k__BackingField == (Object)null)
				{
					<DunGenTileTracker>k__BackingField = ((Component)this).gameObject.GetComponent<DunGenTileTracker>() ?? ((Component)this).gameObject.AddComponent<DunGenTileTracker>();
					<DunGenTileTracker>k__BackingField.lethalBotAI = this;
				}
				return <DunGenTileTracker>k__BackingField;
			}
		}

		public static EntranceTeleport[] EntrancesTeleportArray { get; private set; } = null;


		public static QuicksandTrigger[] QuicksandArray { get; private set; } = null;


		public static ShipTeleporter? InverseTeleporter
		{
			get
			{
				if ((Object)(object)<InverseTeleporter>k__BackingField == (Object)null)
				{
					<InverseTeleporter>k__BackingField = FindTeleporter(inverseTeleporter: true);
				}
				return <InverseTeleporter>k__BackingField;
			}
		}

		public static DissonanceComms? DissonanceComms
		{
			get
			{
				if ((Object)(object)<DissonanceComms>k__BackingField == (Object)null)
				{
					<DissonanceComms>k__BackingField = Object.FindObjectOfType<DissonanceComms>();
				}
				return <DissonanceComms>k__BackingField;
			}
		}

		public static MineshaftElevatorController? ElevatorScript { get; private set; } = null;


		public bool IsInElevatorStartRoom { get; private set; }

		public bool IsInsideElevator
		{
			get
			{
				//IL_0017: Unknown result type (might be due to invalid IL or missing references)
				//IL_001c: Unknown result type (might be due to invalid IL or missing references)
				//IL_002f: Unknown result type (might be due to invalid IL or missing references)
				if ((Object)(object)ElevatorScript != (Object)null)
				{
					Bounds bounds = ElevatorScript.elevatorBounds.bounds;
					return ((Bounds)(ref bounds)).Contains(((Component)NpcController.Npc).transform.position);
				}
				return false;
			}
		}

		public override void Awake()
		{
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Expected O, but got Unknown
			base.enemyBehaviourStates = (EnemyBehaviourState[])(object)new EnemyBehaviourState[Enum.GetNames(typeof(EnumAIStates)).Length];
			int num = 0;
			EnumAIStates[] array = (EnumAIStates[])Enum.GetValues(typeof(EnumAIStates));
			for (int i = 0; i < array.Length; i++)
			{
				EnumAIStates enumAIStates = array[i];
				base.enemyBehaviourStates[num++] = new EnemyBehaviourState
				{
					name = enumAIStates.ToString()
				};
			}
			base.currentBehaviourStateIndex = -1;
		}

		public override void Start()
		{
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Expected O, but got Unknown
			base.AIIntervalTime = 0.3f;
			try
			{
				base.agent = ((Component)this).gameObject.GetComponentInChildren<NavMeshAgent>();
				base.agent.acceleration = float.MaxValue;
				Plugin.LogDebug($"LethalBot Agent Type ID {base.agent.agentTypeID}");
				Plugin.LogDebug($"LethalBot Area Mask {base.agent.areaMask}");
				SetAgent(enabled: false);
				base.enemyType.WaterType = (EnemyWaterType)1;
				base.enemyType.pushPlayerDistance = 0f;
				base.skinnedMeshRenderers = ((Component)this).gameObject.GetComponentsInChildren<SkinnedMeshRenderer>();
				base.meshRenderers = ((Component)this).gameObject.GetComponentsInChildren<MeshRenderer>();
				if ((Object)(object)base.creatureAnimator == (Object)null)
				{
					base.creatureAnimator = ((Component)this).gameObject.GetComponentInChildren<Animator>();
				}
				base.thisNetworkObject = ((Component)this).gameObject.GetComponentInChildren<NetworkObject>();
				base.path1 = new NavMeshPath();
				base.openDoorSpeedMultiplier = base.enemyType.doorSpeedMultiplier;
			}
			catch (Exception arg)
			{
				Plugin.LogError($"Error when initializing lethalBot variables for {((Object)((Component)this).gameObject).name} : {arg}");
			}
		}

		public void Init(EnumSpawnAnimation enumSpawnAnimation, bool clientJoining = false)
		{
			//IL_01d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0186: Unknown result type (might be due to invalid IL or missing references)
			//IL_018b: Unknown result type (might be due to invalid IL or missing references)
			//IL_018e: Unknown result type (might be due to invalid IL or missing references)
			EntrancesTeleportArray = Object.FindObjectsOfType<EntranceTeleport>(false);
			laddersInteractTrigger = RefreshLaddersList();
			doorLocksArray = Object.FindObjectsOfType<DoorLock>(false);
			ElevatorScript = Object.FindObjectOfType<MineshaftElevatorController>();
			QuicksandArray = Object.FindObjectsOfType<QuicksandTrigger>();
			InitImportantColliders();
			LethalBotManager.Instance.RegisterItems();
			if (enumSpawnAnimation != EnumSpawnAnimation.ReinitializePlayer || clientJoining)
			{
				NpcController.Awake(clientJoining);
			}
			DunGenTileTracker.TargetOverride = ((Component)NpcController.Npc).transform;
			MaxHealth = LethalBotIdentity.HpMax;
			NpcController.Npc.health = Mathf.Clamp(NpcController.Npc.health, 1, MaxHealth);
			healthRegenerateTimerMax = 100f / (float)MaxHealth;
			NpcController.Npc.healthRegenerateTimer = healthRegenerateTimerMax;
			base.ventAnimationFinished = true;
			base.isEnemyDead = false;
			((Behaviour)this).enabled = true;
			base.addPlayerVelocityToDestination = 3f;
			StateControllerMovement = EnumStateControllerMovement.FollowAgent;
			if (((NetworkBehaviour)this).IsOwner)
			{
				FearLevel.Value = 0f;
				FearLevelIncreasing.Value = false;
				BotInfectionData.Value = new LethalBotInfection();
				HealInfectionLevel.Value = Random.Range(0.3f, 0.7f);
			}
			searchForScrap = new LethalBotSearchRoutine(this);
			LethalBotBodyCollider = ((Component)NpcController.Npc).GetComponentInChildren<Collider>();
			BoxCollider componentInChildren = ((Component)this).GetComponentInChildren<BoxCollider>();
			if (componentInChildren != null)
			{
				Bounds bounds = LethalBotBodyCollider.bounds;
				componentInChildren.size = ((Bounds)(ref bounds)).extents;
			}
			InitLethalBotVoiceComponent();
			UpdateLethalBotVoiceEffects();
			StartOfRound.Instance.RefreshPlayerVoicePlaybackObjects();
			LineRendererUtil = new LineRendererUtil(6, ((Component)this).transform);
			TeleportAgentAIAndBody(((Component)NpcController.Npc).transform.position, !StartOfRound.Instance.shipHasLanded);
			StateControllerMovement = EnumStateControllerMovement.FollowAgent;
			IsTouchingGroundTimedCheck = new TimedTouchingGroundCheck();
			spawnAnimationCoroutine = BeginLethalBotSpawnAnimation(enumSpawnAnimation);
		}

		private void InitLethalBotVoiceComponent()
		{
			if ((Object)(object)base.creatureVoice == (Object)null)
			{
				AudioSource[] componentsInChildren = ((Component)this).gameObject.GetComponentsInChildren<AudioSource>();
				foreach (AudioSource val in componentsInChildren)
				{
					if (((Object)val).name == "CreatureVoice")
					{
						base.creatureVoice = val;
						break;
					}
				}
			}
			if ((Object)(object)base.creatureVoice == (Object)null)
			{
				Plugin.LogWarning($"Could not initialize lethalBot {BotId} {NpcController.Npc.playerUsername} voice !");
				return;
			}
			NpcController.Npc.currentVoiceChatAudioSource = base.creatureVoice;
			LethalBotVoice = NpcController.Npc.currentVoiceChatAudioSource;
			((Behaviour)LethalBotVoice).enabled = true;
			LethalBotIdentity.Voice.BotID = BotId;
			LethalBotIdentity.Voice.CurrentAudioSource = LethalBotVoice;
			NpcController.OccludeAudioComponent = ((Component)base.creatureVoice).GetComponent<OccludeAudio>();
			AudioLowPassFilter val2 = ((Component)base.creatureVoice).GetComponent<AudioLowPassFilter>();
			if ((Object)(object)val2 == (Object)null)
			{
				val2 = ((Component)base.creatureVoice).gameObject.AddComponent<AudioLowPassFilter>();
			}
			NpcController.AudioLowPassFilterComponent = val2;
			AudioHighPassFilter val3 = ((Component)base.creatureVoice).GetComponent<AudioHighPassFilter>();
			if ((Object)(object)val3 == (Object)null)
			{
				val3 = ((Component)base.creatureVoice).gameObject.AddComponent<AudioHighPassFilter>();
			}
			NpcController.AudioHighPassFilterComponent = val3;
			LethalBotVoice.outputAudioMixerGroup = SoundManager.Instance.playerVoiceMixers[(uint)NpcController.Npc.playerClientId];
			DissonanceComms dissonanceComms = DissonanceComms;
			if ((Object)(object)dissonanceComms != (Object)null)
			{
				Plugin.LogDebug("Lethal Bot " + NpcController.Npc.playerUsername + ": found DissonanceComms!");
				GameObject playbackPrefab = dissonanceComms.PlaybackPrefab;
				AudioSource val4 = ((playbackPrefab != null) ? playbackPrefab.GetComponentInChildren<AudioSource>() : null);
				if ((Object)(object)val4 != (Object)null)
				{
					Plugin.LogDebug("Lethal Bot " + NpcController.Npc.playerUsername + ": found voice prefab!");
					AnimationCurve customCurve = val4.GetCustomCurve((AudioSourceCurveType)0);
					LethalBotVoice.rolloffMode = (AudioRolloffMode)2;
					LethalBotVoice.minDistance = val4.minDistance;
					LethalBotVoice.maxDistance = val4.maxDistance;
					LethalBotVoice.SetCustomCurve((AudioSourceCurveType)0, customCurve);
				}
			}
		}

		private void FixedUpdate()
		{
			UpdateSurfaceRayCast();
		}

		private void UpdateSurfaceRayCast()
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			if (NpcController != null)
			{
				NpcController.IsTouchingGround = IsTouchingGroundTimedCheck.IsTouchingGround(NpcController.Npc.thisPlayerBody.position);
				if (NpcController.IsTouchingGround)
				{
					NpcController.Npc.GetCurrentMaterialStandingOn(false);
				}
			}
		}

		public override void Update()
		{
			//IL_014d: Unknown result type (might be due to invalid IL or missing references)
			//IL_016e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0173: Unknown result type (might be due to invalid IL or missing references)
			//IL_0183: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_05e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0473: Unknown result type (might be due to invalid IL or missing references)
			//IL_048e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0493: Unknown result type (might be due to invalid IL or missing references)
			//IL_0648: Unknown result type (might be due to invalid IL or missing references)
			//IL_0653: Unknown result type (might be due to invalid IL or missing references)
			//IL_067e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0689: Unknown result type (might be due to invalid IL or missing references)
			//IL_0695: Unknown result type (might be due to invalid IL or missing references)
			//IL_069a: Unknown result type (might be due to invalid IL or missing references)
			//IL_069c: Unknown result type (might be due to invalid IL or missing references)
			//IL_06a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0410: Unknown result type (might be due to invalid IL or missing references)
			//IL_041c: Unknown result type (might be due to invalid IL or missing references)
			//IL_042c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0443: Unknown result type (might be due to invalid IL or missing references)
			//IL_0448: Unknown result type (might be due to invalid IL or missing references)
			//IL_044c: Unknown result type (might be due to invalid IL or missing references)
			//IL_06e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_06f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_06f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_04fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_050b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0535: Unknown result type (might be due to invalid IL or missing references)
			//IL_0544: Unknown result type (might be due to invalid IL or missing references)
			//IL_0928: Unknown result type (might be due to invalid IL or missing references)
			//IL_092d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0712: Unknown result type (might be due to invalid IL or missing references)
			//IL_0717: Unknown result type (might be due to invalid IL or missing references)
			//IL_072a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0732: Unknown result type (might be due to invalid IL or missing references)
			//IL_0742: Unknown result type (might be due to invalid IL or missing references)
			//IL_08c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_08ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_08d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_08d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_08e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_086c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0887: Unknown result type (might be due to invalid IL or missing references)
			//IL_088c: Unknown result type (might be due to invalid IL or missing references)
			//IL_07b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_07d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_07d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_07e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0810: Unknown result type (might be due to invalid IL or missing references)
			//IL_081c: Unknown result type (might be due to invalid IL or missing references)
			//IL_082c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0843: Unknown result type (might be due to invalid IL or missing references)
			//IL_0848: Unknown result type (might be due to invalid IL or missing references)
			//IL_084c: Unknown result type (might be due to invalid IL or missing references)
			//IL_09ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_09bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_09d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_09ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_09f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_09f7: Unknown result type (might be due to invalid IL or missing references)
			if (NpcController != null)
			{
				LethalBotIdentity.Hp = ((!NpcController.Npc.isPlayerDead) ? NpcController.Npc.health : 0);
				base.isEnemyDead = !LethalBotIdentity.Alive;
			}
			Quaternion rotation;
			if (!((NetworkBehaviour)this).IsOwner && NpcController != null)
			{
				SetAgent(enabled: false);
				if (State == null || State.GetAIState() != 0)
				{
					State = new BrainDeadState(this);
				}
				if (!State.CheckAllowsTerminalUse() && NpcController.Npc.inTerminalMenu)
				{
					LeaveTerminal();
				}
				if (!NpcController.Npc.isClimbingLadder && !NpcController.Npc.inTerminalMenu && (NpcController.Npc.inSpecialInteractAnimation || NpcController.Npc.enteringSpecialAnimation))
				{
					InteractTrigger currentTriggerInAnimationWith = NpcController.Npc.currentTriggerInAnimationWith;
					if ((Object)(object)currentTriggerInAnimationWith != (Object)null && !currentTriggerInAnimationWith.isLadder)
					{
						NpcController.Npc.thisPlayerBody.localPosition = Vector3.Lerp(NpcController.Npc.thisPlayerBody.localPosition, NpcController.Npc.thisPlayerBody.parent.InverseTransformPoint(currentTriggerInAnimationWith.playerPositionNode.position), Time.deltaTime * 20f);
						NpcController.Npc.thisPlayerBody.rotation = Quaternion.Lerp(NpcController.Npc.thisPlayerBody.rotation, currentTriggerInAnimationWith.playerPositionNode.rotation, Time.deltaTime * 20f);
						NpcController npcController = NpcController;
						rotation = currentTriggerInAnimationWith.playerPositionNode.rotation;
						npcController.SetTurnBodyTowardsDirection(((Quaternion)(ref rotation)).eulerAngles);
					}
				}
				return;
			}
			if (NpcController == null || !((Component)NpcController.Npc).gameObject.activeSelf || !NpcController.Npc.isPlayerControlled || base.isEnemyDead || NpcController.Npc.isPlayerDead)
			{
				SetAgent(enabled: false);
				if (NpcController == null || !((Component)NpcController.Npc).gameObject.activeSelf || (!NpcController.Npc.isPlayerControlled && !NpcController.Npc.isPlayerDead))
				{
					return;
				}
				if (State != null && State.GetAIState() == EnumAIStates.BrainDead)
				{
					if (updateDestinationIntervalLethalBotAI >= 0f)
					{
						updateDestinationIntervalLethalBotAI -= Time.deltaTime;
						return;
					}
					State.DoAI();
					State.TryPlayCurrentStateVoiceAudio();
					updateDestinationIntervalLethalBotAI = base.AIIntervalTime;
				}
				else if (NpcController.Npc.isPlayerDead)
				{
					State = new BrainDeadState(this);
				}
				return;
			}
			if (base.inSpecialAnimation)
			{
				SetAgent(enabled: false);
				return;
			}
			if (!NpcController.Npc.isClimbingLadder && !NpcController.Npc.inTerminalMenu && (NpcController.Npc.inSpecialInteractAnimation || NpcController.Npc.enteringSpecialAnimation))
			{
				InteractTrigger currentTriggerInAnimationWith2 = NpcController.Npc.currentTriggerInAnimationWith;
				if ((Object)(object)currentTriggerInAnimationWith2 != (Object)null && !currentTriggerInAnimationWith2.isLadder)
				{
					NpcController.Npc.thisPlayerBody.localPosition = Vector3.Lerp(NpcController.Npc.thisPlayerBody.localPosition, NpcController.Npc.thisPlayerBody.parent.InverseTransformPoint(currentTriggerInAnimationWith2.playerPositionNode.position), Time.deltaTime * 20f);
					NpcController.Npc.thisPlayerBody.rotation = Quaternion.Lerp(NpcController.Npc.thisPlayerBody.rotation, currentTriggerInAnimationWith2.playerPositionNode.rotation, Time.deltaTime * 20f);
					NpcController npcController2 = NpcController;
					rotation = currentTriggerInAnimationWith2.playerPositionNode.rotation;
					npcController2.SetTurnBodyTowardsDirection(((Quaternion)(ref rotation)).eulerAngles);
				}
				SetAgent(enabled: false);
				((Component)this).transform.position = ((Component)NpcController.Npc).transform.position;
				base.serverPosition = ((Component)NpcController.Npc).transform.position;
				return;
			}
			if ((Object)(object)ElevatorScript != (Object)null)
			{
				if (ElevatorScript.elevatorFinishedMoving)
				{
					timerElevatorCooldown += Time.deltaTime;
				}
				else
				{
					timerElevatorCooldown = 0f;
				}
				if (IsInElevatorStartRoom || base.isOutside)
				{
					if (base.isOutside || Vector3.Distance(((Component)NpcController.Npc).transform.position, ElevatorScript.elevatorBottomPoint.position) < 10f)
					{
						IsInElevatorStartRoom = false;
					}
				}
				else if (Vector3.Distance(((Component)NpcController.Npc).transform.position, ElevatorScript.elevatorTopPoint.position) < 20f)
				{
					IsInElevatorStartRoom = true;
				}
			}
			if (NpcController.HasToMove)
			{
				Vector2 val = default(Vector2);
				((Vector2)(ref val))..ctor(NpcController.MoveVector.x, NpcController.MoveVector.z);
				base.agent.speed = 1f * ((Vector2)(ref val)).magnitude;
				if (NpcController.LookAtTarget.IsLookingForward() || NpcController.LookAtTarget.CanSwapAimState(EnumLookAtPriority.LOW_PRIORITY, lookAtMustExpire: true))
				{
					NpcController.OrderToLookForward();
					NpcController.SetTurnBodyTowardsDirectionWithPosition(((Component)this).transform.position);
				}
			}
			else if (!IsInsideElevator && (State == null || !State.IsSafePathRunning()))
			{
				SetAgent(enabled: false);
			}
			float num = 8f;
			if (NpcController.Npc.jetpackControls)
			{
				num = 15f;
			}
			float num2 = Mathf.Clamp(num * Vector3.Distance(((Component)NpcController.Npc).transform.position, ((Component)this).transform.position), 0.9f, 300f);
			Vector3 val2 = Vector3.MoveTowards(((Component)NpcController.Npc).transform.position, ((Component)this).transform.position, num2 * Time.deltaTime);
			float x = val2.x;
			float z = val2.z;
			bool flag = ShouldFreeMovement();
			bool flag2 = ShouldFixedMovement();
			if (flag || StateControllerMovement == EnumStateControllerMovement.Free)
			{
				StateControllerMovement = EnumStateControllerMovement.Free;
				NpcController.Npc.thisController.Move(NpcController.MoveVector * Time.deltaTime);
			}
			else if (!flag2 && StateControllerMovement == EnumStateControllerMovement.FollowAgent)
			{
				Vector3 position = ((Component)this).transform.position;
				((Component)NpcController.Npc).transform.position = new Vector3(x, position.y, z);
				((Component)this).transform.position = position;
				NpcController.Npc.ResetFallGravity();
			}
			else if (flag2)
			{
				InteractTrigger currentTriggerInAnimationWith3 = NpcController.Npc.currentTriggerInAnimationWith;
				if ((Object)(object)currentTriggerInAnimationWith3 != (Object)null && !currentTriggerInAnimationWith3.isLadder)
				{
					NpcController.Npc.thisPlayerBody.localPosition = Vector3.Lerp(NpcController.Npc.thisPlayerBody.localPosition, NpcController.Npc.thisPlayerBody.parent.InverseTransformPoint(currentTriggerInAnimationWith3.playerPositionNode.position), Time.deltaTime * 20f);
					NpcController.Npc.thisPlayerBody.rotation = Quaternion.Lerp(NpcController.Npc.thisPlayerBody.rotation, currentTriggerInAnimationWith3.playerPositionNode.rotation, Time.deltaTime * 20f);
					NpcController npcController3 = NpcController;
					rotation = currentTriggerInAnimationWith3.playerPositionNode.rotation;
					npcController3.SetTurnBodyTowardsDirection(((Quaternion)(ref rotation)).eulerAngles);
				}
				((Component)this).transform.position = ((Component)NpcController.Npc).transform.position;
				base.serverPosition = ((Component)NpcController.Npc).transform.position;
			}
			if (StateControllerMovement == EnumStateControllerMovement.Free && NpcController.IsTouchingGround && !flag)
			{
				StateControllerMovement = EnumStateControllerMovement.FollowAgent;
				RaycastHit groundHit = IsTouchingGroundTimedCheck.GetGroundHit(NpcController.Npc.thisPlayerBody.position);
				TeleportAgentAIAndBody(((RaycastHit)(ref groundHit)).point);
				SetDestinationToPositionLethalBotAI(base.destination);
			}
			if (NpcController.HasToMove || (((Behaviour)base.agent).isActiveAndEnabled && !base.agent.isOnNavMesh))
			{
				StartOfRound instance = StartOfRound.Instance;
				Vector3 val3 = base.agent.velocity;
				if (((Vector3)(ref val3)).sqrMagnitude < 0.002f && !IsUsingOffMeshLink() && !IsInsideElevator && (LethalBotManager.AreWeInOrbit(instance) || LethalBotManager.IsTheShipLanded(instance)))
				{
					if (stuckTimer > 4f)
					{
						Plugin.LogWarning($"Bot {NpcController.Npc.playerClientId} {NpcController.Npc.playerUsername} is stuck! Telporting to closest node!");
						val3 = base.agent.velocity;
						object arg = ((Vector3)(ref val3)).sqrMagnitude;
						val3 = NpcController.Npc.oldPlayerPosition - ((Component)NpcController.Npc).transform.position;
						Plugin.LogWarning($"Agent velocity: {arg} Previous distance from last position: {((Vector3)(ref val3)).sqrMagnitude}");
						State?.OnBotStuck();
						stuckTimer = 0f;
					}
					else
					{
						stuckTimer += Time.deltaTime;
					}
				}
				else if (stuckTimer > 0f)
				{
					stuckTimer = Mathf.Max(stuckTimer - Time.deltaTime, 0f);
				}
			}
			else
			{
				stuckTimer = 0f;
			}
			State?.LethalBotInteraction?.Update(this, Time.deltaTime);
			if (updateDestinationIntervalLethalBotAI >= 0f)
			{
				updateDestinationIntervalLethalBotAI -= Time.deltaTime;
				return;
			}
			SetAgent(!flag2);
			((EnemyAI)this).DoAIInterval();
			updateDestinationIntervalLethalBotAI = base.AIIntervalTime;
		}

		public override void DoAIInterval()
		{
			if (!base.isEnemyDead && !NpcController.Npc.isPlayerDead && State != null)
			{
				State.DoAI();
				OpenDoorIfNeeded();
				FollowCrouchStateIfCan();
				if (CheckProximityForEyelessDogs())
				{
					LethalBotIdentity.Voice.TryStopAudioFadeOut();
				}
				else
				{
					State.TryPlayCurrentStateVoiceAudio();
				}
				if (!State.CheckAllowsTerminalUse() && NpcController.Npc.inTerminalMenu)
				{
					LeaveTerminal();
				}
				State.UseHeldItem();
			}
		}

		public void UpdateController()
		{
			if (!NpcController.IsControllerInCruiser)
			{
				NpcController.Update();
			}
		}

		private void LateUpdate()
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			if (NpcController == null)
			{
				return;
			}
			((Component)LethalBotVoice).transform.position = ((Component)NpcController.Npc.gameplayCamera).transform.position;
			SetLethalBotInElevator();
			if (((NetworkBehaviour)this).IsOwner)
			{
				if (FearLevelIncreasing.Value)
				{
					FearLevelIncreasing.Value = false;
				}
				else if (NpcController.Npc.isPlayerDead)
				{
					NetworkVariable<float> fearLevel = FearLevel;
					fearLevel.Value -= Time.deltaTime * 0.5f;
				}
				else
				{
					NetworkVariable<float> fearLevel2 = FearLevel;
					fearLevel2.Value -= Time.deltaTime * 0.055f;
				}
			}
		}

		private bool ShouldFreeMovement()
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			if (NpcController.IsTouchingGround)
			{
				RaycastHit groundHit = IsTouchingGroundTimedCheck.GetGroundHit(NpcController.Npc.thisPlayerBody.position);
				Collider collider = ((RaycastHit)(ref groundHit)).collider;
				if ((Object)(object)collider != (Object)null && dictColliderToBridge.TryGetValue(collider, out BridgeTrigger value) && (Object)(object)value != (Object)null && value.fallenBridgeColliders.Length != 0 && value.fallenBridgeColliders[0].enabled)
				{
					Plugin.LogDebug(NpcController.Npc.playerUsername + " on fallen bridge ! " + ((Object)collider).name);
					IsTouchingGroundTimedCheck.ForceRecalculationNextThink(invalidateIsTouchingGround: true);
					return true;
				}
			}
			if (StartOfRound.Instance.suckingPlayersOutOfShip)
			{
				Plugin.LogDebug(NpcController.Npc.playerUsername + " being sucked out of the ship!");
				return true;
			}
			if (NpcController.Npc.externalForces.y > 7.1f)
			{
				Plugin.LogDebug($"{NpcController.Npc.playerUsername} externalForces {NpcController.Npc.externalForces.y}");
				return true;
			}
			if (((Vector3)(ref NpcController.Npc.externalForceAutoFade)).sqrMagnitude > 4f)
			{
				Plugin.LogDebug($"{NpcController.Npc.playerUsername} externalForceAutoFade {((Vector3)(ref NpcController.Npc.externalForceAutoFade)).sqrMagnitude}");
				return true;
			}
			return false;
		}

		private bool ShouldFixedMovement()
		{
			StartOfRound instance = StartOfRound.Instance;
			if ((NpcController.Npc.isInElevator || NpcController.Npc.isInHangarShipRoom) && !LethalBotManager.AreWeInOrbit(instance) && (LethalBotManager.IsTheShipLeaving(instance) || !LethalBotManager.IsTheShipLanded(instance)))
			{
				return true;
			}
			if ((Object)(object)NpcController.Npc.currentTriggerInAnimationWith != (Object)null)
			{
				return true;
			}
			return false;
		}

		private void FollowCrouchStateIfCan()
		{
			if (State != null)
			{
				bool? flag = State.ShouldBotCrouch();
				if (flag.HasValue)
				{
					if (flag.Value && NpcController.Npc.isSprinting)
					{
						NpcController.OrderToStopSprint();
					}
					if (NpcController.Npc.isCrouching != flag.Value)
					{
						Plugin.LogDebug(string.Format("[{0}] Decided to {1}.", State, flag.Value ? "crouch" : "stand"));
						NpcController.OrderToToggleCrouch();
					}
					return;
				}
			}
			if (SyncedEntry<bool>.op_Implicit(Plugin.Config.FollowCrouchWithPlayer) && (Object)(object)base.targetPlayer != (Object)null && IsFollowingTargetPlayer())
			{
				if (base.targetPlayer.isCrouching && !NpcController.Npc.isCrouching)
				{
					NpcController.OrderToToggleCrouch();
				}
				else if (!base.targetPlayer.isCrouching && NpcController.Npc.isCrouching)
				{
					NpcController.OrderToToggleCrouch();
				}
			}
		}

		public bool IsFollowingTargetPlayer()
		{
			switch (State.GetAIState())
			{
			case EnumAIStates.GetCloseToPlayer:
			case EnumAIStates.JustLostPlayer:
			case EnumAIStates.ChillWithPlayer:
			case EnumAIStates.PlayerInCruiser:
				return true;
			case EnumAIStates.FetchingObject:
				if ((Object)(object)base.targetPlayer != (Object)null && base.targetPlayer.isPlayerControlled)
				{
					return !base.targetPlayer.isPlayerDead;
				}
				return false;
			default:
				return false;
			}
		}

		public bool IsFollowingLocalPlayer()
		{
			if ((Object)(object)base.targetPlayer == (Object)null || (Object)(object)base.targetPlayer != (Object)(object)GameNetworkManager.Instance.localPlayerController || !base.targetPlayer.isPlayerControlled || base.targetPlayer.isPlayerDead)
			{
				return false;
			}
			EnumAIStates aIState = State.GetAIState();
			if ((uint)(aIState - 2) <= 4u)
			{
				return true;
			}
			return false;
		}

		public override void OnCollideWithPlayer(Collider other)
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			if (((Component)other).CompareTag("Player"))
			{
				PlayerControllerB component = ((Component)other).GetComponent<PlayerControllerB>();
				if ((Object)(object)component != (Object)null && !LethalBotManager.Instance.IsPlayerLethalBot(component))
				{
					NpcController npcController = NpcController;
					npcController.NearEntitiesPushVector += Vector3.Normalize((((Component)NpcController.Npc).transform.position - ((Component)other).transform.position) * 100f) * 1.2f;
				}
			}
		}

		public override void OnCollideWithEnemy(Collider other, EnemyAI collidedEnemy)
		{
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: 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_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			if (((NetworkBehaviour)this).IsOwner && !((Object)(object)collidedEnemy == (Object)null) && !(((object)collidedEnemy).GetType() == typeof(LethalBotAI)) && !(((object)collidedEnemy).GetType() == typeof(FlowerSnakeEnemy)))
			{
				Vector3 val = ((Component)NpcController.Npc).transform.position - ((Component)other).transform.position;
				if (((Vector3)(ref val)).sqrMagnitude < collidedEnemy.enemyType.pushPlayerDistance * collidedEnemy.enemyType.pushPlayerDistance)
				{
					NpcController npcController = NpcController;
					npcController.NearEntitiesPushVector += Vector3.Normalize((((Component)NpcController.Npc).transform.position - ((Component)other).transform.position) * 100f) * collidedEnemy.enemyType.pushPlayerForce;
				}
			}
		}

		public override void DetectNoise(Vector3 noisePosition, float noiseLoudness, int timesPlayedInOneSpot = 0, int noiseID = 0)
		{
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			if (NpcController != null && ((Component)NpcController.Npc).gameObject.activeSelf && NpcController.Npc.isPlayerControlled && !base.isEnemyDead && !NpcController.Npc.isPlayerDead && State != null && noiseID == 75)
			{
				LethalBotIdentity.Voice.TryStopAudioFadeOut();
				if (((NetworkBehaviour)this).IsOwner)
				{
					LethalBotIdentity.Voice.SetNewRandomCooldownAudio();
				}
				Plugin.LogDebug($"Lethal Bot {NpcController.Npc.playerUsername} detected noise noisePosition {noisePosition}, noiseLoudness {noiseLoudness}, timesPlayedInOneSpot {timesPlayedInOneSpot}, noiseID {noiseID}");
				State.PlayerHeard(noisePosition);
			}
		}

		public static bool IsValidPathToTarget(Vector3 startPosition, Vector3 endPosition, int areaMask, ref NavMeshPath path, bool calculatePathDistance, out float pathDistance)
		{
			//IL_0008: 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_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: 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)
			pathDistance = 0f;
			if (!NavMesh.CalculatePath(startPosition, endPosition, areaMask, path))
			{
				return false;
			}
			NavMeshPath obj = path;
			Vector3[] array = ((obj != null) ? obj.corners : null);
			if (array == null || array.Length == 0)
			{
				return false;
			}
			Vector3 val = array[^1] - RoundManager.Instance.GetNavMeshPosition(endPosition, RoundManager.Instance.navHit, 2.7f, -1);
			if (((Vector3)(ref val)).sqrMagnitude > 2.25f)
			{
				return false;
			}
			if (calculatePathDistance)
			{
				for (int i = 1; i < array.Length; i++)
				{
					pathDistance += Vector3.Distance(array[i - 1], array[i]);
				}
			}
			return true;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public bool IsValidPathToTarget(Vector3 targetPos, bool calculatePathDistance = false, float nearestNavAreaRange = 2.7f, float maxRangeToEnd = 1.5f)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			return IsValidPathToTarget(targetPos, ref base.path1, calculatePathDistance, nearestNavAreaRange, maxRangeToEnd);
		}

		public bool IsValidPathToTarget(Vector3 targetPos, ref NavMeshPath path, bool calculatePathDistance = false, float nearestNavAreaRange = 2.7f, float maxRangeToEnd = 1.5f)
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			base.pathDistance = 0f;
			bool enabled = ((Behaviour)base.agent).enabled;
			SetAgent(enabled: true);
			if (base.agent.isOnNavMesh && !base.agent.CalculatePath(targetPos, path))
			{
				Plugin.LogDebug("IsValidPathToTarget: Path could not be calculated");
				return false;
			}
			NavMeshPath obj = path;
			Vector3[] array = ((obj != null) ? obj.corners : null);
			if (array == null || array.Length == 0)
			{
				Plugin.LogDebug("IsValidPathToTarget: Path is invalid");
				return false;
			}
			Vector3 val = array[^1] - RoundManager.Instance.GetNavMeshPosition(targetPos, RoundManager.Instance.navHit, nearestNavAreaRange, -1);
			if (((Vector3)(ref val)).sqrMagnitude > maxRangeToEnd * maxRangeToEnd)
			{
				Plugin.LogDebug($"IsValidPathToTarget: Path is not complete; final waypoint of path was too far from target position: {targetPos}");
				return false;
			}
			if (calculatePathDistance)
			{
				for (int i = 1; i < array.Length; i++)
				{
					base.pathDistance += Vector3.Distance(array[i - 1], array[i]);
				}
			}
			if (!((NetworkBehaviour)this).IsOwner)
			{
				SetAgent(enabled: false);
			}
			else
			{
				SetAgent(enabled);
			}
			return true;
		}

		public bool IsPathDangerous(Vector3 targetPos, bool calculatePathDistance = false, bool useEyePosition = true, bool checkForEnemies = true)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0539: Unknown result type (might be due to invalid IL or missing references)
			//IL_053e: Unknown result type (might be due to invalid IL or missing references)
			//IL_054d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0552: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: 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_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_056a: Unknown result type (might be due to invalid IL or missing references)
			//IL_056c: Unknown result type (might be due to invalid IL or missing references)
			//IL_055c: Unknown result type (might be due to invalid IL or missing references)
			//IL_055e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0560: Unknown result type (might be due to invalid IL or missing references)
			//IL_07d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_07e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_037a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0381: Unknown result type (might be due to invalid IL or missing references)
			//IL_0815: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_05b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_05b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_05c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_05c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_05ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_05cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_05d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_05db: Unknown result type (might be due to invalid IL or missing references)
			//IL_05e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0165: Unknown result type (might be due to invalid IL or missing references)
			//IL_0167: Unknown result type (might be due to invalid IL or missing references)
			//IL_0171: Unknown result type (might be due to invalid IL or missing references)
			//IL_0176: Unknown result type (might be due to invalid IL or missing references)
			//IL_017b: Unknown result type (might be due to invalid IL or missing references)
			//IL_017d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0187: Unknown result type (might be due to invalid IL or missing references)
			//IL_018c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0191: Unknown result type (might be due to invalid IL or missing references)
			//IL_0877: Unknown result type (might be due to invalid IL or missing references)
			//IL_0879: Unknown result type (might be due to invalid IL or missing references)
			//IL_087b: Unknown result type (might be due to invalid IL or missing references)
			//IL_087d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0884: Unknown result type (might be due to invalid IL or missing references)
			//IL_0886: Unknown result type (might be due to invalid IL or missing references)
			//IL_088a: Unknown result type (might be due to invalid IL or missing references)
			//IL_088f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0899: Unknown result type (might be due to invalid IL or missing references)
			//IL_08ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_08b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0418: Unknown result type (might be due to invalid IL or missing references)
			//IL_041a: Unknown result type (might be due to invalid IL or missing references)
			//IL_041c: Unknown result type (might be due to invalid IL or missing references)
			//IL_041e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0425: Unknown result type (might be due to invalid IL or missing references)
			//IL_0427: Unknown result type (might be due to invalid IL or missing references)
			//IL_042b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0430: Unknown result type (might be due to invalid IL or missing references)
			//IL_043a: Unknown result type (might be due to invalid IL or missing references)
			//IL_044f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0454: Unknown result type (might be due to invalid IL or missing references)
			//IL_0858: Unknown result type (might be due to invalid IL or missing references)
			//IL_0848: Unknown result type (might be due to invalid IL or missing references)
			//IL_084d: Unknown result type (might be due to invalid IL or missing references)
			//IL_08e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_08eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_08f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_08f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_08fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_08ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_08ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_048a: Unknown result type (might be due to invalid IL or missing references)
			//IL_048c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0492: Unknown result type (might be due to invalid IL or missing references)
			//IL_0497: Unknown result type (might be due to invalid IL or missing references)
			//IL_049c: Unknown result type (might be due to invalid IL or missing references)
			//IL_04a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_046b: Unknown result type (might be due to invalid IL or missing references)
			//IL_068a: Unknown result type (might be due to invalid IL or missing references)
			//IL_068c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0693: Unknown result type (might be due to invalid IL or missing references)
			//IL_0698: Unknown result type (might be due to invalid IL or missing references)
			//IL_06a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_06a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_06a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_06ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_0242: Unknown result type (might be due to invalid IL or missing references)
			//IL_0247: Unknown result type (might be due to invalid IL or missing references)
			//IL_0249: Unknown result type (might be due to invalid IL or missing references)
			//IL_024e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0665: Unknown result type (might be due to invalid IL or missing references)
			//IL_066b: Invalid comparison between Unknown and I4
			//IL_0216: Unknown result type (might be due to invalid IL or missing references)
			//IL_021c: Invalid comparison between Unknown and I4
			//IL_0720: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0733: Unknown result type (might be due to invalid IL or missing references)
			//IL_0735: Unknown result type (might be due to invalid IL or missing references)
			//IL_0737: Unknown result type (might be due to invalid IL or missing references)
			//IL_073d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0742: Unknown result type (might be due to invalid IL or missing references)
			//IL_0747: Unknown result type (might be due to invalid IL or missing references)
			//IL_0749: Unknown result type (might be due to invalid IL or missing references)
			//IL_0753: Unknown result type (might be due to invalid IL or missing references)
			//IL_0758: Unknown result type (might be due to invalid IL or missing references)
			//IL_072e: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02de: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_02cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_0777: Unknown result type (might be due to invalid IL or missing references)
			//IL_0779: Unknown result type (might be due to invalid IL or missing references)
			//IL_0318: Unknown result type (might be due to invalid IL or missing references)
			//IL_031a: Unknown result type (might be due to invalid IL or missing references)
			if (!IsValidPathToTarget(targetPos))
			{
				return true;
			}
			Plugin.LogDebug($"Bot {NpcController.Npc.playerUsername} is checking if a path to {targetPos} is dangerous!");
			Vector3 position = ((Component)NpcController.Npc.gameplayCamera).transform.position;
			bool flag = false;
			float num = position.y - ((Component)NpcController.Npc).transform.position.y;
			float num2 = NpcController.DrowningTimer;
			float num3 = ((NpcController.Npc.movementSpeed > 0f) ? NpcController.Npc.movementSpeed : 4.5f);
			num3 /= NpcController.Npc.carryWeight;
			Vector3 val3;
			if (calculatePathDistance)
			{
				for (int i = 1; i < base.path1.corners.Length; i++)
				{
					Vector3 val = base.path1.corners[i - 1];
					Vector3 val2 = base.path1.corners[i];
					float num4 = Vector3.Distance(val, val2);
					base.pathDistance += num4;
					if (i > 15)
					{
						continue;
					}
					if (checkForEnemies)
					{
						if (!flag && i > 8 && num4 < 2f)
						{
							if (base.DebugEnemy)
							{
								Plugin.LogDebug($"Distance between corners {i} and {i - 1} under 3 meters; skipping LOS check");
								Debug.DrawRay(val + Vector3.up * 0.2f, val2 + Vector3.up * 0.2f, Color.magenta, 0.2f);
							}
							flag = true;
							continue;
						}
						flag = false;
						RoundManager instance = RoundManager.Instance;
						foreach (EnemyAI spawnedEnemy in instance.SpawnedEnemies)
						{
							if (spawnedEnemy.isEnemyDead || !spawnedEnemy.isOutside)
							{
								continue;
							}
							float? num5 = GetFearRangeForEnemies(spawnedEnemy, EnumFearQueryType.PathfindingAvoid);
							if (!num5.HasValue)
							{
								continue;
							}
							if (base.isOutside && !spawnedEnemy.enemyType.canSeeThroughFog && (int)TimeOfDay.Instance.currentLevelWeather == 3)
							{
								num5 = Mathf.Clamp(num5.Value, 0f, 30f);
							}
							val3 = ((Component)spawnedEnemy).transform.position - val;
							if (((Vector3)(ref val3)).sqrMagnitude > num5 * num5)
							{
								continue;
							}
							Vector3 val4 = ((useEyePosition && (Object)(object)spawnedEnemy.eye != (Object)null) ? spawnedEnemy.eye.position : ((Component)spawnedEnemy).transform.position);
							if (!Physics.Linecast(val + Vector3.up * num, val4 + Vector3.up * 0.2f, StartOfRound.Instance.collidersAndRoomMaskAndDefault, (QueryTriggerInteraction)1))
							{
								return true;
							}
							if (Physics.Linecast(val, val2, 262144))
							{
								if (base.DebugEnemy)
								{
									Plugin.LogDebug($"{base.enemyType.enemyName}: The path is blocked by line of sight at corner {i}");
								}
								return true;
							}
						}
					}
					Plugin.LogDebug($"Testing quicksand safety between current node {val2} and previous node {val}");
					QuicksandTrigger[] quicksandArray = QuicksandArray;
					foreach (QuicksandTrigger val5 in quicksandArray)
					{
						if (!((Behaviour)val5).isActiveAndEnabled)
						{
							continue;
						}
						Bounds val6 = default(Bounds);
						bool flag2 = false;
						Collider[] components = ((Component)val5).gameObject.GetComponents<Collider>();
						foreach (Collider val7 in components)
						{
							if ((Object)(object)val7 != (Object)null)
							{
								if (!flag2)
								{
									val6 = val7.bounds;
									flag2 = true;
								}
								else
								{
									((Bounds)(ref val6)).Encapsulate(val7.bounds);
								}
							}
						}
						if (!flag2)
						{
							continue;
						}
						Vector3 vLineA = val;
						Vector3 vLineB = val2;
						Vector3 navMeshPosition = RoundManager.Instance.GetNavMeshPosition(GetClosestPointOnLineSegment(vLineA, vLineB, ((Bounds)(ref val6)).center), RoundManager.Instance.navHit, 2.7f, base.agent.areaMask);
						if (!val5.isWater)
						{
							Plugin.LogDebug("This is quicksand!");
							if (((Bounds)(ref val6)).Contains(navMeshPosition))
							{
								Plugin.LogDebug("Segment intersects solid quicksand!");
								return true;
							}
							continue;
						}
						Plugin.LogDebug("This is water!");
						Vector3 val8 = navMeshPosition + Vector3.up * num;
						if (((Bounds)(ref val6)).Contains(val8))
						{
							Plugin.LogDebug("Simulated head intersects water!");
							float num6 = num4 / num3;
							float num7 = num6 / 12f;
							num2 -= num7;
							Plugin.LogDebug($"Time left in water: {num2:F2}");
							if (num2 <= 0f)
							{
								Plugin.LogDebug("Path would drown the bot! Marking path as dangerous!");
								return true;
							}
						}
					}
				}
			}
			else
			{
				for (int l = 1; l < base.path1.corners.Length; l++)
				{
					Vector3 val9 = base.path1.corners[l - 1];
					Vector3 val10 = base.path1.corners[l];
					if (base.DebugEnemy)
					{
						Debug.DrawLine(val9, val10, Color.green);
					}
					float num8 = Vector3.Distance(val9, val10);
					if (checkForEnemies)
					{
						if (!flag && l > 8 && num8 < 2f)
						{
							if (base.DebugEnemy)
							{
								Plugin.LogDebug($"Distance between corners {l} and {l - 1} under 3 meters; skipping LOS check");
								Debug.DrawRay(val9 + Vector3.up * 0.2f, val10 + Vector3.up * 0.2f, Color.magenta, 0.2f);
							}
							flag = true;
							continue;
						}
						flag = false;
						RoundManager instance2 = RoundManager.Instance;
						foreach (EnemyAI spawnedEnemy2 in instance2.SpawnedEnemies)
						{
							if (spawnedEnemy2.isEnemyDead || !spawnedEnemy2.isOutside)
							{
								continue;
							}
							float? num9 = GetFearRangeForEnemies(spawnedEnemy2, EnumFearQueryType.PathfindingAvoid);
							if (!num9.HasValue)
							{
								continue;
							}
							if (base.isOutside && !spawnedEnemy2.enemyType.canSeeThroughFog && (int)TimeOfDay.Instance.currentLevelWeather == 3)
							{
								num9 = Mathf.Clamp(num9.Value, 0f, 30f);
							}
							Vector3 val11 = Vector3.Lerp(val9, val10, 0.5f);
							val3 = ((Component)spawnedEnemy2).transform.position - val11;
							if (((Vector3)(ref val3)).sqrMagnitude > num9 * num9)
							{
								continue;
							}
							Vector3 val12 = ((useEyePosition && (Object)(object)spawnedEnemy2.eye != (Object)null) ? spawnedEnemy2.eye.position : ((Component)spawnedEnemy2).transform.position);
							if (!Physics.Linecast(val11 + Vector3.up * num, val12 + Vector3.up * 0.2f, StartOfRound.Instance.collidersAndRoomMaskAndDefault, (QueryTriggerInteraction)1))
							{
								return true;
							}
							if (Physics.Linecast(val9, val10, 262144))
							{
								if (base.DebugEnemy)
								{
									Plugin.LogDebug($"{base.enemyType.enemyName}: The path is blocked by line of sight at corner {l}");
								}
								return true;
							}
						}
					}
					Plugin.LogDebug($"Testing quicksand safety between current node {val10} and previous node {val9}");
					QuicksandTrigger[] quicksandArray2 = QuicksandArray;
					foreach (QuicksandTrigger val13 in quicksandArray2)
					{
						if (!((Behaviour)val13).isActiveAndEnabled)
						{
							continue;
						}
						Bounds val14 = default(Bounds);
						bool flag3 = false;
						Collider[] components2 = ((Component)val13).gameObject.GetComponents<Collider>();
						foreach (Collider val15 in components2)
						{
							if ((Object)(object)val15 != (Object)null)
							{
								if (!flag3)
								{
									val14 = val15.bounds;
									flag3 = true;
								}
								else
								{
									((Bounds)(ref val14)).Encapsulate(val15.bounds);
								}
							}
						}
						if (!flag3)
						{
							continue;
						}
						Vector3 vLineA2 = val9;
						Vector3 vLineB2 = val10;
						Vector3 navMeshPosition2 = RoundManager.Instance.GetNavMeshPosition(GetClosestPointOnLineSegment(vLineA2, vLineB2, ((Bounds)(ref val14)).center), RoundManager.Instance.navHit, 2.7f, base.agent.areaMask);
						if (!val13.isWater)
						{
							Plugin.LogDebug("This is quicksand!");
							if (((Bounds)(ref val14)).Contains(navMeshPosition2))
							{
								Plugin.LogDebug("Segment intersects solid quicksand!");
								return true;
							}
							continue;
						}
						Plugin.LogDebug("This is water!");
						Vector3 val16 = navMeshPosition2 + Vector3.up * num;
						if (((Bounds)(ref val14)).Contains(val16))
						{
							Plugin.LogDebug("Simulated head intersects water!");
							float num10 = num8 / num3;
							float num11 = num10 / 12f;
							num2 -= num11;
							Plugin.LogDebug($"Time left in water: {num2:F2}");
							if (num2 <= 0f)
							{
								Plugin.LogDebug("Path would drown the bot! Marking path as dangerous!");
								return true;
							}
						}
					}
					if (l > 15)
					{
						if (base.DebugEnemy)
						{
							Plugin.LogDebug(base.enemyType.enemyName + ": Reached corner 15, stopping checks now");
						}
						return false;
					}
				}
			}
			return false;
		}

		public Task<(bool isDangerous, bool isPathValid, float pathDistance)> TryStartPathDangerousAsync(Vector3 targetPos, bool calculatePathDistance = false, bool useEyePosition = true, bool checkForEnemies = true, bool checkForQuicksand = true, CancellationToken token = default(CancellationToken))
		{
			//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: Expected O, but got Unknown
			//IL_003d: 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_0067: Unknown result type (might be due to invalid IL or missing references)
			if (token.IsCancellationRequested)
			{
				return Task.FromCanceled<(bool, bool, float)>(token);
			}
			Plugin.LogDebug($"Bot {NpcController.Npc.playerUsername} is checking if a path to {targetPos} is dangerous! This will be called asynchronously!");
			NavMeshPath path = new NavMeshPath();
			if (!IsValidPathToTarget(targetPos, ref path))
			{
				Plugin.LogDebug($"Bot {NpcController.Npc.playerUsername} failed to find a path to {targetPos}!");
				return Task.FromResult((true, false, 0f));
			}
			Plugin.LogDebug($"Path found to target {targetPos}. Checking for danger...");
			return IsPathDangerousAsync(path, calculatePathDistance, useEyePosition, checkForEnemies, checkForQuicksand, token);
		}

		private async Task<(bool isDangerous, bool isPathValid, float pathDistance)> IsPathDangerousAsync(NavMeshPath ourPath, bool calculatePathDistance = false, bool useEyePosition = true, bool checkForEnemies = true, bool checkForQuicksand = true, CancellationToken token = default(CancellationToken))
		{
			if (token.IsCancellationRequested)
			{
				token.ThrowIfCancellationRequested();
			}
			Vector3[] corners = ((ourPath != null) ? ourPath.corners : null);
			if (corners == null || corners.Length == 0)
			{
				return (true, false, 0f);
			}
			bool isPathDangerous = false;
			bool skipLOSCheckThisSegment = false;
			float pathDistance = 0f;
			float headOffset = ((Component)NpcController.Npc.gameplayCamera).transform.position.y - ((Component)NpcController.Npc).transform.position.y;
			float predictedDrownTimer = NpcController.DrowningTimer;
			float moveSpeed2 = ((NpcController.Npc.movementSpeed > 0f) ? NpcController.Npc.movementSpeed : 4.5f);
			moveSpeed2 /= NpcController.Npc.carryWeight;
			for (int i = 1; i < corners.Length; i++)
			{
				if (token.IsCancellationRequested)
				{
					token.ThrowIfCancellationRequested();
				}
				Vector3 previousNode = corners[i - 1];
				Vector3 nodePos = corners[i];
				float tempDistance = Vector3.Distance(previousNode, nodePos);
				Plugin.LogDebug($"Checking path segment from {previousNode} to {nodePos}. Distance: {tempDistance}.");
				if (calculatePathDistance)
				{
					pathDistance += tempDistance;
				}
				if (i > 15)
				{
					if (!calculatePathDistance)
					{
						Plugin.LogDebug(NpcController.Npc.playerUsername + ": Reached corner 15, stopping checks now");
						return (false, true, pathDistance);
					}
					continue;
				}
				if (i % 10 == 0)
				{
					await Task.Yield();
				}
				if (isPathDangerous)
				{
					if (!calculatePathDistance)
					{
						break;
					}
					continue;
				}
				if (checkForEnemies)
				{
					if (!skipLOSCheckThisSegment && i > 8 && tempDistance < 2f)
					{
						skipLOSCheckThisSegment = true;
						Plugin.LogDebug($"Skipping redundant LOS checks at segment {i} due to proximity and small distance.");
					}
					else
					{
						skipLOSCheckThisSegment = false;
					}
					bool flag = !skipLOSCheckThisSegment;
					bool flag2 = flag;
					if (flag2)
					{
						flag2 = await IsEnemyDangerousAtSegment(previousNode, nodePos, headOffset, useEyePosition, token);
					}
					if (flag2)
					{
						Plugin.LogDebug($"Danger detected at segment {i} from {previousNode} to {nodePos}. Path is dangerous!");
						if (!calculatePathDistance)
						{
							return (true, true, pathDistance);
						}
						isPathDangerous = true;
					}
				}
				if (!checkForQuicksand)
				{
					continue;
				}
				(bool, float) tuple = await CheckQuicksandDanger(previousNode, nodePos, headOffset, tempDistance, moveSpeed2, predictedDrownTimer, token);
				bool item = tuple.Item1;
				float item2 = tuple.Item2;
				predictedDrownTimer = item2;
				if (item)
				{
					Plugin.LogDebug($"Danger detected due to quicksand or water at segment {i}. Path is dangerous!");
					if (!calculatePathDistance)
					{
						return (true, true, pathDistance);
					}
					isPathDangerous = true;
				}
			}
			base.pathDistance = pathDistance;
			if (!isPathDangerous)
			{
				Plugin.LogDebug("Path is safe. No danger detected.");
			}
			return (isPathDangerous, true, pathDistance);
		}

		private async Task<bool> IsEnemyDangerousAtSegment(Vector3 from, Vector3 to, float headOffset, bool useEyePosition, CancellationToken token = default(CancellationToken))
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			Plugin.LogDebug($"{NpcController.Npc.playerUsername} is checking path segment from {from} to {to} for enemy exposure...");
			RoundManager instanceRM = RoundManager.Instance;
			Vector3 travelMidPoint = instanceRM.GetNavMeshPosition(Vector3.Lerp(from, to, 0.5f), instanceRM.navHit, 2.7f, -1);
			bool ourWeOutside = base.isOutside;
			string skipText = (ourWeOutside ? "not outside" : "not inside");
			for (int i = 0; i < instanceRM.SpawnedEnemies.Count; i++)
			{
				if (token.IsCancellationRequested)
				{
					token.ThrowIfCancellationRequested();
				}
				EnemyAI enemy = instanceRM.SpawnedEnemies[i];
				if (i % 10 == 0)
				{
					await Task.Yield();
				}
				Plugin.LogDebug(NpcController.Npc.playerUsername + " is checking " + enemy.enemyType.enemyName + " for exposure...");
				if ((Object)(object)enemy == (Object)null)
				{
					Plugin.LogDebug($"Enemy At Index {i}: Skipped (null)");
					continue;
				}
				if (enemy.isEnemyDead || ourWeOutside != enemy.isOutside)
				{
					Plugin.LogDebug(enemy.enemyType.enemyName + ": Skipped (dead or " + skipText + ")");
					continue;
				}
				float? num = GetFearRangeForEnemies(enemy, EnumFearQueryType.PathfindingAvoid);
				if (!num.HasValue)
				{
					Plugin.LogDebug(enemy.enemyType.enemyName + ": Skipped (not a threat)");
					continue;
				}
				if (ourWeOutside && !enemy.enemyType.canSeeThroughFog && (int)TimeOfDay.Instance.currentLevelWeather == 3)
				{
					num = Mathf.Clamp(num.Value, 0f, 30f);
				}
				Vector3 position = ((Component)enemy).transform.position;
				Vector3 navMeshPosition = instanceRM.GetNavMeshPosition(GetClosestPointOnLineSegment(from, to, position), instanceRM.navHit, 2.7f, -1);
				Vector3 val = navMeshPosition - position;
				if (((Vector3)(ref val)).sqrMagnitude > num * num)
				{
					Plugin.LogDebug(enemy.enemyType.enemyName + ": Skipped (outside danger range)");
					continue;
				}
				Vector3 val2 = ((useEyePosition && (Object)(object)enemy.eye != (Object)null) ? enemy.eye.position : position);
				val2 += Vector3.up * 0.3f;
				if (!Physics.Linecast(navMeshPosition + Vector3.up * headOffset, val2, StartOfRound.Instance.collidersAndRoomMaskAndDefault, (QueryTriggerInteraction)1))
				{
					Plugin.LogDebug($"{enemy.enemyType.enemyName}: Segment is exposed from closest {navMeshPosition} to view position!");
					return true;
				}
				if (!Physics.Linecast(travelMidPoint + Vector3.up * headOffset, val2, StartOfRound.Instance.collidersAndRoomMaskAndDefault, (QueryTriggerInteraction)1))
				{
					Plugin.LogDebug($"{enemy.enemyType.enemyName}: Segment is exposed from midpoint {travelMidPoint} to view position!");
					return true;
				}
			}
			return false;
		}

		private async Task<(bool isDangerous, float updatedDownTimer)> CheckQuicksandDanger(Vector3 from, Vector3 to, float headOffset, float tempDistance, float moveSpeed, float predictedDrownTimer, CancellationToken token = default(CancellationToken))
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			if (QuicksandArray == null || QuicksandArray.Length == 0)
			{
				if (predictedDrownTimer <= 0f)
				{
					Plugin.LogDebug("Path would drown the bot! Marking path as dangerous!");
					return (true, predictedDrownTimer);
				}
				return (false, predictedDrownTimer);
			}
			bool pathGoesThroughWater = false;
			Plugin.LogDebug($"{NpcController.Npc.playerUsername} is testing quicksand safety between previous node {from} and current node {to}");
			for (int i = 0; i < QuicksandArray.Length; i++)
			{
				if (token.IsCancellationRequested)
				{
					token.ThrowIfCancellationRequested();
				}
				QuicksandTrigger quicksand = QuicksandArray[i];
				if (i % 5 == 0)
				{
					await Task.Yield();
				}
				if ((Object)(object)quicksand == (Object)null || !((Behaviour)quicksand).isActiveAndEnabled)
				{
					continue;
				}
				Bounds val = default(Bounds);
				bool flag = false;
				Collider[] components = ((Component)quicksand).gameObject.GetComponents<Collider>();
				foreach (Collider val2 in components)
				{
					if ((Object)(object)val2 != (Object)null)
					{
						if (!flag)
						{
							val = val2.bounds;
							flag = true;
						}
						else
						{
							((Bounds)(ref val)).Encapsulate(val2.bounds);
						}
					}
				}
				if (!flag)
				{
					continue;
				}
				float num = moveSpeed / (2f * (1f * quicksand.movementHinderance));
				Vector3 navMeshPosition = RoundManager.Instance.GetNavMeshPosition(GetClosestPointOnLineSegment(from, to, ((Bounds)(ref val)).center), RoundManager.Instance.navHit, 2.7f, base.agent.areaMask);
				if (!quicksand.isWater)
				{
					Plugin.LogDebug("This is quicksand!");
					if (((Bounds)(ref val)).Contains(navMeshPosition))
					{
						Plugin.LogDebug("Segment intersects solid quicksand!");
						return (true, predictedDrownTimer);
					}
					continue;
				}
				Plugin.LogDebug("This is water!");
				Vector3 val3 = navMeshPosition + Vector3.up * headOffset;
				if (((Bounds)(ref val)).Contains(val3))
				{
					Plugin.LogDebug("Simulated head intersects water!");
					float num2 = tempDistance / num;
					float num3 = num2 / 12f;
					predictedDrownTimer -= num3;
					Plugin.LogDebug($"Time left in water: {predictedDrownTimer:F2}");
					pathGoesThroughWater = true;
					if (predictedDrownTimer <= 0f)
					{
						Plugin.LogDebug("Path would drown the bot! Marking path as dangerous!");
						return (true, predictedDrownTimer);
					}
				}
			}
			if (!pathGoesThroughWater)
			{
				float num4 = tempDistance / moveSpeed;
				predictedDrownTimer = Mathf.Clamp(predictedDrownTimer + num4 / 12f, 0f, 1f);
			}
			return (false, predictedDrownTimer);
		}

		internal static Vector3 GetClosestPointOnLineSegment(Vector3 vLineA, Vector3 vLineB, Vector3 point)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: 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)
			if (vLineA == vLineB)
			{
				return vLineA;
			}
			float closestPointOnLineSegmentT = GetClosestPointOnLineSegmentT(vLineA, vLineB, point);
			return Vector3.Lerp(vLineA, vLineB, closestPointOnLineSegmentT);
		}

		private static float GetClosestPointOnLineSegmentT(Vector3 vLineA, Vector3 vLineB, Vector3 point)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			Vector3 val = vLineB - vLineA;
			float num = Vector3.Dot(val, val);
			if (num < 1E-05f)
			{
				return 0f;
			}
			return Mathf.Clamp01(Vector3.Dot(point - vLineA, val) / num);
		}

		public bool PathIsIntersectedByLineOfSight(Vector3 targetPos, out bool isPathVaild, bool calculatePathDistance = false, bool avoidLineOfSight = true, EnemyAI? checkLOSToTarget = null, bool useEnemyEyePos = true)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_012f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0149: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0175: Unknown result type (might be due to invalid IL or missing references)
			//IL_0167: Unknown result type (might be due to invalid IL or missing references)
			//IL_017a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0199: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01da: Unknown result type (might be due to invalid IL or missing references)
			//IL_01df: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02de: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0300: Unknown result type (might be due to invalid IL or missing references)
			//IL_0302: Unknown result type (might be due to invalid IL or missing references)
			//IL_0309: Unknown result type (might be due to invalid IL or missing references)
			//IL_0310: Unknown result type (might be due to invalid IL or missing references)
			//IL_031b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0320: Unknown result type (might be due to invalid IL or missing references)
			//IL_0322: Unknown result type (might be due to invalid IL or missing references)
			//IL_0324: Unknown result type (might be due to invalid IL or missing references)
			//IL_032b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0330: Unknown result type (might be due to invalid IL or missing references)
			//IL_0335: Unknown result type (might be due to invalid IL or missing references)
			//IL_0263: Unknown result type (might be due to invalid IL or missing references)
			//IL_0265: Unknown result type (might be due to invalid IL or missing references)
			//IL_026f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0274: Unknown result type (might be due to invalid IL or missing references)
			//IL_0279: Unknown result type (might be due to invalid IL or missing references)
			//IL_027b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0285: Unknown result type (might be due to invalid IL or missing references)
			//IL_028a: Unknown result type (might be due to invalid IL or missing references)
			//IL_028f: Unknown result type (might be due to invalid IL or missing references)
			isPathVaild = true;
			base.pathDistance = 0f;
			if (base.agent.isOnNavMesh && !base.agent.CalculatePath(targetPos, base.path1))
			{
				if (base.DebugEnemy)
				{
					Debug.Log((object)"Path could not be calculated");
				}
				isPathVaild = false;
				return true;
			}
			if (base.DebugEnemy)
			{
				for (int i = 1; i < base.path1.corners.Length; i++)
				{
					Debug.DrawLine(base.path1.corners[i - 1], base.path1.corners[i], Color.red);
				}
			}
			NavMeshPath path = base.path1;
			Vector3[] array = ((path != null) ? path.corners : null);
			if (array == null || array.Length == 0)
			{
				isPathVaild = false;
				return true;
			}
			Vector3 val = array[^1] - RoundManager.Instance.GetNavMeshPosition(targetPos, RoundManager.Instance.navHit, 2.7f, -1);
			if (((Vector3)(ref val)).sqrMagnitude > 2.25f)
			{
				if (base.DebugEnemy)
				{
					Debug.Log((object)$"Path is not complete; final waypoint of path was too far from target position: {targetPos}");
				}
				isPathVaild = false;
				return true;
			}
			if (calculatePathDistance || avoidLineOfSight)
			{
				bool flag = false;
				float num = ((Component)NpcController.Npc.gameplayCamera).transform.position.y - ((Component)NpcController.Npc).transform.position.y;
				RoundManager instance = RoundManager.Instance;
				Vector3 val2 = (((Object)(object)checkLOSToTarget != (Object)null) ? ((Component)checkLOSToTarget).transform.position : Vector3.zero);
				Vector3 val3 = ((useEnemyEyePos && (Object)(object)checkLOSToTarget != (Object)null && (Object)(object)checkLOSToTarget.eye != (Object)null) ? checkLOSToTarget.eye.position : val2);
				val3 += Vector3.up * 0.3f;
				for (int j = 1; j < array.Length; j++)
				{
					Vector3 val4 = array[j - 1];
					Vector3 val5 = array[j];
					float num2 = Vector3.Distance(val4, val5);
					if (calculatePathDistance)
					{
						base.pathDistance += num2;
					}
					if (j > 15)
					{
						if (!calculatePathDistance)
						{
							Plugin.LogDebug(NpcController.Npc.playerUsername + ": Reached corner 15, stopping checks now");
							return false;
						}
						continue;
					}
					if (!flag && j > 8 && num2 < 2f)
					{
						if (base.DebugEnemy)
						{
							Debug.Log((object)$"Distance between corners {j} and {j - 1} under 3 meters; skipping LOS check");
							Debug.DrawRay(val4 + Vector3.up * 0.2f, val5 + Vector3.up * 0.2f, Color.magenta, 0.2f);
						}
						flag = true;
						continue;
					}
					flag = false;
					if ((Object)(object)checkLOSToTarget != (Object)null)
					{
						Vector3 navMeshPosition = instance.GetNavMeshPosition(GetClosestPointOnLineSegment(val4, val5, val2), instance.navHit, 2.7f, -1);
						if (!Physics.Linecast(navMeshPosition + Vector3.up * num, val3, StartOfRound.Instance.collidersAndRoomMaskAndDefault, (QueryTriggerInteraction)1))
						{
							return true;
						}
						Vector3 navMeshPosition2 = instance.GetNavMeshPosition(Vector3.Lerp(val4, val5, 0.5f), instance.navHit, 2.7f, -1);
						if (!Physics.Linecast(navMeshPosition2 + Vector3.up * num, val3, StartOfRound.Instance.collidersAndRoomMaskAndDefault, (QueryTriggerInteraction)1))
						{
							return true;
						}
					}
				}
			}
			return false;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void SetAgent(bool enabled)
		{
			if ((Object)(object)base.agent != (Object)null && ((Behaviour)base.agent).enabled != enabled)
			{
				((Behaviour)base.agent).enabled = enabled;
				if (enabled && base.agent.isOnNavMesh)
				{
					int areaFromName = NavMesh.GetAreaFromName("Water");
					base.agent.SetAreaCost(areaFromName, 5f);
					base.agent.SetAreaCost(26, 5f);
					base.agent.SetAreaCost(27, 50f);
				}
			}
		}

		public void SetDestinationToPositionLethalBotAI(Vector3 position)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: 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_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			base.moveTowardsDestination = true;
			base.movingTowardsTargetPlayer = false;
			if (previousWantedDestination != position)
			{
				previousWantedDestination = position;
				hasDestinationChanged = true;
				base.destination = position;
			}
		}

		public void OrderMoveToDestination()
		{
			//IL_00e9: 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_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			NpcController.OrderToMove();
			if ((!hasDestinationChanged && updateDestinationTimer.HasStarted() && !updateDestinationTimer.Elapsed()) || !((Behaviour)base.agent).isActiveAndEnabled || !base.agent.isOnNavMesh || IsUsingOffMeshLink() || base.isEnemyDead || NpcController.Npc.isPlayerDead)
			{
				return;
			}
			if (!IsValidPathToTarget(base.destination))
			{
				try
				{
					base.destination = RoundManager.Instance.GetNavMeshPosition(base.destination, default(NavMeshHit), 2.7f, -1);
				}
				catch (Exception ex)
				{
					Plugin.LogDebug($"{NpcController.Npc.playerUsername} GetNavMeshPosition error : {ex.Message} , InnerException : {ex.InnerException}");
				}
			}
			((EnemyAI)this).SetDestinationToPosition(base.destination, false);
			base.agent.SetDestination(base.destination);
			updateDestinationTimer.Start(1f);
			hasDestinationChanged = false;
		}

		public void StopMoving()
		{
			if (NpcController.HasToMove)
			{
				hasDestinationChanged = true;
				NpcController.OrderToStopMoving();
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public bool IsClientOwnerOfLethalBot()
		{
			return ((NetworkBehaviour)this).OwnerClientId == GameNetworkManager.Instance.localPlayerController.actualClientId;
		}

		public void InitStateToSearchingNoTarget(bool isInverseTeleport = false)
		{
			if (!base.isEnemyDead && !NpcController.Npc.isPlayerDead)
			{
				if (isInverseTeleport)
				{
					State = new SearchingForScrapState(this);
				}
				else
				{
					State = new ChillAtShipState(this);
				}
				base.targetPlayer = null;
			}
		}

		private int MaxHealthPercent(int percentage)
		{
			return LethalBotManager.Instance.MaxHealthPercent(percentage, MaxHealth);
		}

		public void CheckAndBringCloserTeleportLethalBot(float percentageOfDestination)
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0131: Unknown result type (might be due to invalid IL or missing references)
			//IL_0136: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0109: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0149: Unknown result type (might be due to invalid IL or missing references)
			//IL_0156: Unknown result type (might be due to invalid IL or missing references)
			//IL_015b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0160: Unknown result type (might be due to invalid IL or missing references)
			//IL_016d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0172: Unknown result type (might be due to invalid IL or missing references)
			bool flag = false;
			StartOfRound instance = StartOfRound.Instance;
			Transform transform = ((Component)NpcController.Npc.gameplayCamera).transform;
			Vector3 val = ((Component)NpcController.Npc.thisPlayerBody).transform.position + (base.destination - ((Component)NpcController.Npc).transform.position) * percentageOfDestination;
			Vector3 val2 = val + new Vector3(0f, 1f, 0f);
			for (int i = 0; i < instance.allPlayerScripts.Length; i++)
			{
				PlayerControllerB val3 = instance.allPlayerScripts[i];
				if (val3.isPlayerDead || !val3.isPlayerControlled || LethalBotManager.Instance.IsPlayerLethalBot(val3))
				{
					continue;
				}
				if (!Physics.Linecast(((Component)val3.gameplayCamera).transform.position, transform.position, StartOfRound.Instance.collidersAndRoomMaskAndDefault))
				{
					Vector3 val4 = transform.position - ((Component)val3.gameplayCamera).transform.position;
					if (Vector3.Angle(((Component)val3.gameplayCamera).transform.forward, val4) < val3.gameplayCamera.fieldOfView)
					{
						flag = true;
						break;
					}
				}
				if (!Physics.Linecast(((Component)val3.gameplayCamera).transform.position, val2, StartOfRound.Instance.collidersAndRoomMaskAndDefault))
				{
					Vector3 val4 = val2 - ((Component)val3.gameplayCamera).transform.position;
					if (Vector3.Angle(((Component)val3.gameplayCamera).transform.forward, val4) < val3.gameplayCamera.fieldOfView)
					{
						flag = true;
						break;
					}
				}
			}
			if (!flag)
			{
				TeleportLethalBot(val);
			}
		}

		public PlayerControllerB? CheckLOSForTarget(float width = 45f, int range = 60, int proximityAwareness = -1)
		{
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Invalid comparison between Unknown and I4
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)base.targetPlayer == (Object)null)
			{
				return null;
			}
			if (!((EnemyAI)this).PlayerIsTargetable(base.targetPlayer, false, false, true))
			{
				return null;
			}
			if (base.isOutside && !base.enemyType.canSeeThroughFog && (int)TimeOfDay.Instance.currentLevelWeather == 3)
			{
				range = Mathf.Clamp(range, 0, 30);
			}
			Transform transform = ((Component)NpcController.Npc.gameplayCamera).transform;
			Vector3 position = ((Component)base.targetPlayer.gameplayCamera).transform.position;
			if (Vector3.Distance(position, transform.position) < (float)range && !Physics.Linecast(transform.position, position, StartOfRound.Instance.collidersAndRoomMaskAndDefault))
			{
				Vector3 val = position - transform.position;
				if (Vector3.Angle(transform.forward, val) < width || (proximityAwareness != -1 && Vector3.Distance(transform.position, position) < (float)proximityAwareness))
				{
					return base.targetPlayer;
				}
			}
			return null;
		}

		public PlayerControllerB? CheckLOSForLethalBotHavingTargetInLOS(float width = 45f, int range = 60, int proximityAwareness = -1)
		{
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			StartOfRound instance = StartOfRound.Instance;
			Transform transform = ((Component)NpcController.Npc.gameplayCamera).transform;
			PlayerControllerB[] allPlayerScripts = instance.allPlayerScripts;
			foreach (PlayerControllerB val in allPlayerScripts)
			{
				if (val.playerClientId == NpcController.Npc.playerClientId || val.isPlayerDead || !val.isPlayerControlled)
				{
					continue;
				}
				LethalBotAI lethalBotAI = LethalBotManager.Instance.GetLethalBotAI(val);
				if ((Object)(object)lethalBotAI == (Object)null || (Object)(object)((EnemyAI)lethalBotAI).targetPlayer == (Object)null || lethalBotAI.State.GetAIState() == EnumAIStates.JustLostPlayer)
				{
					continue;
				}
				Vector3 position = ((Component)val.gameplayCamera).transform.position;
				if (Vector3.Distance(position, transform.position) < (float)range && !Physics.Linecast(transform.position, position, instance.collidersAndRoomMaskAndDefault))
				{
					Vector3 val2 = position - transform.position;
					if ((Vector3.Angle(transform.forward, val2) < width || (proximityAwareness != -1 && Vector3.Distance(transform.position, position) < (float)proximityAwareness)) && (Object)(object)((EnemyAI)lethalBotAI).targetPlayer == (Object)(object)base.targetPlayer)
					{
						Plugin.LogDebug($"{NpcController.Npc.playerClientId} Found lethalBot {val.playerUsername} who knows target {base.targetPlayer.playerUsername}");
						return base.targetPlayer;
					}
				}
			}
			return null;
		}

		public PlayerControllerB? CheckLOSForClosestPlayer(float width = 45f, int range = 60, int proximityAwareness = -1, float bufferDistance = 0f)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Invalid comparison between Unknown and I4
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0196: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_0128: Unknown result type (might be due to invalid IL or missing references)
			if (base.isOutside && !base.enemyType.canSeeThroughFog && (int)TimeOfDay.Instance.currentLevelWeather == 3)
			{
				range = Mathf.Clamp(range, 0, 30);
			}
			List<PlayerControllerB> otherGroupMembers = GroupManager.Instance.GetOtherGroupMembers(NpcController.Npc);
			StartOfRound instance = StartOfRound.Instance;
			Transform transform = ((Component)NpcController.Npc.gameplayCamera).transform;
			float num = 1000f;
			int num2 = -1;
			for (int i = 0; i < instance.allPlayerScripts.Length; i++)
			{
				PlayerControllerB val = instance.allPlayerScripts[i];
				if (!val.isPlayerControlled || val.isPlayerDead || (!otherGroupMembers.Contains(val) && LethalBotManager.Instance.IsPlayerLethalBot(val)))
				{
					continue;
				}
				Vector3 position = ((Component)val.gameplayCamera).transform.position;
				Vector3 val2 = position - ((Component)this).transform.position;
				if (!(((Vector3)(ref val2)).sqrMagnitude > (float)(range * range)) && ((EnemyAI)this).PlayerIsTargetable(val, false, false, true) && !Physics.Linecast(transform.position, position, instance.collidersAndRoomMaskAndDefault))
				{
					Vector3 val3 = position - transform.position;
					float num3 = Vector3.Distance(transform.position, position);
					if ((Vector3.Angle(transform.forward, val3) < width || (proximityAwareness != -1 && num3 < (float)proximityAwareness)) && num3 < num)
					{
						num = num3;
						num2 = i;
					}
				}
			}
			if ((Object)(object)base.targetPlayer != (Object)null && num2 != -1 && (Object)(object)base.targetPlayer != (Object)(object)instance.allPlayerScripts[num2] && bufferDistance > 0f && Mathf.Abs(num - Vector3.Distance(((Component)this).transform.position, ((Component)base.targetPlayer).transform.position)) < bufferDistance)
			{
				return null;
			}
			if (num2 < 0)
			{
				return null;
			}
			base.mostOptimalDistance = num;
			return instance.allPlayerScripts[num2];
		}

		public EnemyAI? CheckLOSForEnemy(float width = 45f, int range = 20, int proximityAwareness = -1)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Invalid comparison between Unknown and I4
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0228: Unknown result type (might be due to invalid IL or missing references)
			//IL_022d: Unknown result type (might be due to invalid IL or missing references)
			if (base.isOutside && !base.enemyType.canSeeThroughFog && (int)TimeOfDay.Instance.currentLevelWeather == 3)
			{
				range = Mathf.Clamp(range, 0, 30);
			}
			StartOfRound instance = StartOfRound.Instance;
			RoundManager instance2 = RoundManager.Instance;
			Transform transform = ((Component)NpcController.Npc.gameplayCamera).transform;
			EnemyAI result = null;
			float num = float.MaxValue;
			foreach (EnemyAI spawnedEnemy in instance2.SpawnedEnemies)
			{
				if ((Object)(object)spawnedEnemy == (Object)null || spawnedEnemy.isEnemyDead)
				{
					continue;
				}
				Vector3 position = ((Component)spawnedEnemy).transform.position;
				Vector3 val = position - transform.position;
				float sqrMagnitude = ((Vector3)(ref val)).sqrMagnitude;
				if (sqrMagnitude > (float)(range * range))
				{
					continue;
				}
				Vector3 val2 = (((Object)(object)spawnedEnemy.eye != (Object)null) ? spawnedEnemy.eye.position : position);
				if (Physics.Linecast(transform.position, val2, instance.collidersAndRoomMaskAndDefault) || (instance2.GetLayermaskForEnemySizeLimit(spawnedEnemy.enemyType, false, -1) != 0 && !spawnedEnemy.isInsidePlayerShip && NpcController.Npc.isInHangarShipRoom))
				{
					continue;
				}
				float? fearRangeForEnemies = GetFearRangeForEnemies(spawnedEnemy);
				if (!fearRangeForEnemies.HasValue || sqrMagnitude > fearRangeForEnemies * fearRangeForEnemies)
				{
					continue;
				}
				if (proximityAwareness > -1 && sqrMagnitude < (float)proximityAwareness * (float)proximityAwareness)
				{
					Plugin.LogDebug(NpcController.Npc.playerUsername + " DANGER CLOSE \"" + spawnedEnemy.enemyType.enemyName + "\" " + ((Object)spawnedEnemy.enemyType).name);
					MaskedPlayerEnemy val3 = (MaskedPlayerEnemy)(object)((spawnedEnemy is MaskedPlayerEnemy) ? spawnedEnemy : null);
					if (val3 != null)
					{
						DictKnownMasked[val3] = true;
					}
					if (sqrMagnitude < num)
					{
						result = spawnedEnemy;
						num = sqrMagnitude;
					}
				}
				else if (Vector3.Angle(transform.forward, val) < width)
				{
					Plugin.LogDebug(NpcController.Npc.playerUsername + " DANGER LOS \"" + spawnedEnemy.enemyType.enemyName + "\" " + ((Object)spawnedEnemy.enemyType).name);
					MaskedPlayerEnemy val4 = (MaskedPlayerEnemy)(object)((spawnedEnemy is MaskedPlayerEnemy) ? spawnedEnemy : null);
					if (val4 != null)
					{
						DictKnownMasked[val4] = true;
					}
					if (sqrMagnitude < num)
					{
						result = spawnedEnemy;
						num = sqrMagnitude;
					}
				}
			}
			return result;
		}

		public bool AreWeExposed(bool bypassCooldown = false)
		{
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: Unknown result type (might be due to invalid IL or missing references)
			//IL_011d: Unknown result type (might be due to invalid IL or missing references)
			//IL_011e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Invalid comparison between Unknown and I4
			//IL_0197: Unknown result type (might be due to invalid IL or missing references)
			//IL_018c: Unknown result type (might be due to invalid IL or missing references)
			//IL_019c: Unknown result type (might be due to invalid IL or missing references)
			//IL_019e: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_01af: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b4: Unknown result type (might be due to invalid IL or missing references)
			if (!bypassCooldown && Time.timeSinceLevelLoad - nextExposedToEnemyTimer < 0.9f)
			{
				return _areWeExposed;
			}
			nextExposedToEnemyTimer = Time.timeSinceLevelLoad;
			Vector3 position = ((Component)NpcController.Npc).transform.position;
			float num = ((Component)NpcController.Npc.gameplayCamera).transform.position.y - position.y;
			Vector3 val = position + Vector3.up * num;
			RoundManager instance = RoundManager.Instance;
			foreach (EnemyAI spawnedEnemy in instance.SpawnedEnemies)
			{
				if (spawnedEnemy.isEnemyDead || base.isOutside != spawnedEnemy.isOutside)
				{
					continue;
				}
				float? num2 = GetFearRangeForEnemies(spawnedEnemy, EnumFearQueryType.PathfindingAvoid);
				if (!num2.HasValue)
				{
					continue;
				}
				if (base.isOutside && !spawnedEnemy.enemyType.canSeeThroughFog && (int)TimeOfDay.Instance.currentLevelWeather == 3)
				{
					num2 = Mathf.Clamp(num2.Value, 0f, 30f);
				}
				Vector3 position2 = ((Component)spawnedEnemy).transform.position;
				Vector3 val2 = position2 - val;
				if (((Vector3)(ref val2)).sqrMagnitude <= num2 * num2)
				{
					Vector3 val3 = (((Object)(object)spawnedEnemy.eye != (Object)null) ? spawnedEnemy.eye.position : position2);
					if (!Physics.Linecast(val3 + Vector3.up * 0.25f, val, StartOfRound.Instance.collidersAndRoomMaskAndDefault, (QueryTriggerInteraction)1))
					{
						_areWeExposed = true;
						return true;
					}
				}
			}
			_areWeExposed = false;
			return false;
		}

		public float? GetFearRangeForEnemies(EnemyAI enemy, EnumFearQueryType queryType = EnumFearQueryType.BotPanic)
		{
			LethalBotFearQuery fearQuery = new LethalBotFearQuery((EnemyAI?)(object)this, enemy, queryType);
			return LethalBotManager.GetFearRangeForEnemy(fearQuery);
		}

		public float? GetFearRangeForEnemies(EnemyAI enemy, PlayerControllerB? playerToCheck)
		{
			if ((Object)(object)playerToCheck == (Object)null)
			{
				return null;
			}
			LethalBotFearQuery fearQuery = new LethalBotFearQuery((EnemyAI?)(object)this, enemy, playerToCheck, EnumFearQueryType.PlayerTeleport);
			return LethalBotManager.GetFearRangeForEnemy(fearQuery);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public float? GetFearRangeForEnemies(LethalBotFearQuery fearQuery)
		{
			return LethalBotManager.GetFearRangeForEnemy(fearQuery);
		}

		public bool CanEnemyBeKilled(EnemyAI enemy, bool isMissionController = false)
		{
			return CanEnemyBeKilled(enemy, HasRangedWeapon(), isHumanPlayer: false, isMissionController);
		}

		public static bool CanEnemyBeKilled(EnemyAI enemy, bool hasRangedWeapon = false, bool isHumanPlayer = false, bool isMissionController = false)
		{
			if (SyncedEntry<bool>.op_Implicit(Plugin.Config.ShouldKillEverything))
			{
				return true;
			}
			bool flag = (float)enemy.stunnedIndefinitely > 0f || enemy.stunNormalizedTimer > 0f;
			if (enemy is CentipedeAI || enemy is MaskedPlayerEnemy || enemy is CrawlerAI || enemy is HoarderBugAI)
			{
				return true;
			}
			NutcrackerEnemyAI val = (NutcrackerEnemyAI)(object)((enemy is NutcrackerEnemyAI) ? enemy : null);
			if (val != null && (hasRangedWeapon || isHumanPlayer || flag) && (enemy.currentBehaviourStateIndex == 2 || nutcrackerIsInspecting.Invoke(val)))
			{
				return true;
			}
			if (enemy is FlowermanAI || enemy is SandSpiderAI || enemy is BaboonBirdAI)
			{
				return hasRangedWeapon || isHumanPlayer || flag;
			}
			if (enemy is ButlerEnemyAI || enemy is MouthDogAI || enemy is CaveDwellerAI)
			{
				return isHumanPlayer;
			}
			BushWolfEnemy val2 = (BushWolfEnemy)(object)((enemy is BushWolfEnemy) ? enemy : null);
			if (val2 != null)
			{
				if ((Object)(object)val2.draggingPlayer != (Object)null)
				{
					return true;
				}
				if (!(hasRangedWeapon || isHumanPlayer || flag))
				{
					return enemy.isInsidePlayerShip;
				}
				return true;
			}
			if (enemy is PumaAI || enemy is CadaverBloomAI)
			{
				if (isMissionController)
				{
					return enemy.isInsidePlayerShip;
				}
				return true;
			}
			return false;
		}

		public bool CheckProximityForEyelessDogs(bool bypassCooldown = false)
		{
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			if (!bypassCooldown && Time.timeSinceLevelLoad - nextEyelessdogCheckTimer < 0.9f)
			{
				return _isEyelessDogInPromimity;
			}
			nextEyelessdogCheckTimer = Time.timeSinceLevelLoad;
			RoundManager instance = RoundManager.Instance;
			Vector3 position = ((Component)NpcController.Npc).transform.position;
			foreach (EnemyAI spawnedEnemy in instance.SpawnedEnemies)
			{
				if (!spawnedEnemy.isEnemyDead && (spawnedEnemy is MouthDogAI || spawnedEnemy.enemyType.enemyName == "MouthDog"))
				{
					float num = 30f;
					Vector3 val = ((Component)spawnedEnemy).transform.position - position;
					if (((Vector3)(ref val)).sqrMagnitude < num * num)
					{
						_isEyelessDogInPromimity = true;
						return true;
					}
				}
			}
			_isEyelessDogInPromimity = false;
			return false;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void ReParentLethalBot(Transform newParent)
		{
			NpcController.ReParentNotSpawnedTransform(newParent);
		}

		public VehicleController? GetVehicleCruiserTargetPlayerIsIn()
		{
			if ((Object)(object)base.targetPlayer == (Object)null || base.targetPlayer.isPlayerDead)
			{
				return null;
			}
			VehicleController vehicleController = LethalBotManager.Instance.VehicleController;
			if ((Object)(object)vehicleController == (Object)null)
			{
				return null;
			}
			if (base.targetPlayer.inVehicleAnimation)
			{
				return vehicleController;
			}
			return null;
		}

		public string GetSizedBillboardStateIndicator()
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = ((Component)StartOfRound.Instance.localPlayerController).transform.position - ((Component)NpcController.Npc).transform.position;
			int num = Math.Clamp((int)(100f + 2.5f * ((Vector3)(ref val)).sqrMagnitude), 100, 800);
			return string.Format(arg1: (!((NetworkBehaviour)this).IsOwner) ? stateIndicatorServer : ((State == null) ? string.Empty : State.GetBillboardStateIndicator()), format: "<size={0}%>{1}</size>", arg0: num);
		}

		internal static ShipTeleporter? FindTeleporter(bool inverseTeleporter = false)
		{
			ShipTeleporter[] array = Object.FindObjectsOfType<ShipTeleporter>(false);
			ShipTeleporter[] array2 = array;
			foreach (ShipTeleporter val in array2)
			{
				if (!((Object)(object)val == (Object)null) && val.isInverseTeleporter == inverseTeleporter)
				{
					return val;
				}
			}
			return null;
		}

		public GrabbableObject? FindItemOnShip(Func<GrabbableObject, bool> filter)
		{
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			GrabbableObject result = null;
			float num = float.MaxValue;
			for (int i = 0; i < LethalBotManager.grabbableObjectsInMap.Count; i++)
			{
				GameObject val = LethalBotManager.grabbableObjectsInMap[i];
				if ((Object)(object)val == (Object)null)
				{
					LethalBotManager.grabbableObjectsInMap.TrimExcess();
					continue;
				}
				GrabbableObject component = val.GetComponent<GrabbableObject>();
				if ((Object)(object)component != (Object)null && component.isInShipRoom && filter(component))
				{
					Vector3 val2 = ((Component)component).transform.position - ((Component)NpcController.Npc).transform.position;
					float sqrMagnitude = ((Vector3)(ref val2)).sqrMagnitude;
					if (sqrMagnitude < num && IsGrabbableObjectGrabbable(component))
					{
						num = sqrMagnitude;
						result = component;
					}
				}
			}
			return result;
		}

		private InteractTrigger[] RefreshLaddersList()
		{
			List<InteractTrigger> list = new List<InteractTrigger>();
			InteractTrigger[] array = Resources.FindObjectsOfTypeAll<InteractTrigger>();
			InteractTrigger[] array2 = array;
			foreach (InteractTrigger val in array2)
			{
				if (!((Object)(object)val == (Object)null) && val.isLadder && (Object)(object)val.ladderHorizontalPosition != (Object)null)
				{
					list.Add(val);
				}
			}
			return list.ToArray();
		}

		public InteractTrigger? GetLadderIfWantsToUseLadder()
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: 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_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: Unknown result type (might be due to invalid IL or missing references)
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_0125: Unknown result type (might be due to invalid IL or missing references)
			//IL_0126: Unknown result type (might be due to invalid IL or missing references)
			//IL_012b: Unknown result type (might be due to invalid IL or missing references)
			bool flag = false;
			OffMeshLinkData val = base.agent.currentOffMeshLinkData;
			if (!((OffMeshLinkData)(ref val)).valid)
			{
				val = base.agent.nextOffMeshLinkData;
				flag = true;
			}
			if (!((OffMeshLinkData)(ref val)).valid || offMeshLinkCoroutine != null)
			{
				return null;
			}
			Vector3 position = ((Component)NpcController.Npc).transform.position;
			Vector3 startPos = ((OffMeshLinkData)(ref val)).startPos;
			Vector3 endPos = ((OffMeshLinkData)(ref val)).endPos;
			Vector3 val2 = startPos - position;
			float sqrMagnitude = ((Vector3)(ref val2)).sqrMagnitude;
			val2 = endPos - position;
			Vector3 val3 = ((!(sqrMagnitude < ((Vector3)(ref val2)).sqrMagnitude)) ? endPos : startPos);
			InteractTrigger result = null;
			float num = 6.25f;
			InteractTrigger[] array = laddersInteractTrigger;
			foreach (InteractTrigger val4 in array)
			{
				if ((Object)(object)val4 == (Object)null)
				{
					continue;
				}
				Vector3 position2 = val4.bottomOfLadderPosition.position;
				Vector3 position3 = val4.topOfLadderPosition.position;
				val2 = position2 - val3;
				float sqrMagnitude2 = ((Vector3)(ref val2)).sqrMagnitude;
				val2 = position3 - val3;
				float sqrMagnitude3 = ((Vector3)(ref val2)).sqrMagnitude;
				Vector3 val5;
				float num2;
				bool flag2;
				if (sqrMagnitude2 < sqrMagnitude3)
				{
					val5 = position2;
					num2 = sqrMagnitude2;
					flag2 = true;
				}
				else
				{
					val5 = position3;
					num2 = sqrMagnitude3;
					flag2 = false;
				}
				if (!(num2 < num))
				{
					continue;
				}
				if (flag)
				{
					val2 = val5 - position;
					if (!(((Vector3)(ref val2)).sqrMagnitude < 6.25f))
					{
						continue;
					}
				}
				Plugin.LogDebug(NpcController.Npc.playerUsername + " Path wants to climb " + (flag2 ? "UP" : "DOWN") + " ladder");
				NpcController.OrderToGoUpDownLadder(!flag2);
				num = num2;
				result = val4;
			}
			return result;
		}

		public EntranceTeleport? IsEntranceCloseForBoth(Vector3 entityPos1, Vector3 entityPos2)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			EntranceTeleport[] entrancesTeleportArray = EntrancesTeleportArray;
			foreach (EntranceTeleport val in entrancesTeleportArray)
			{
				Vector3 val2 = entityPos1 - val.entrancePoint.position;
				if (((Vector3)(ref val2)).sqrMagnitude < 16f)
				{
					val2 = entityPos2 - val.entrancePoint.position;
					if (((Vector3)(ref val2)).sqrMagnitude < 16f)
					{
						return val;
					}
				}
			}
			return null;
		}

		public Vector3? GetTeleportPosOfEntrance(EntranceTeleport? entranceToUse)
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)entranceToUse == (Object)null || !entranceToUse.FindExitPoint())
			{
				return null;
			}
			return entranceToUse.exitScript.entrancePoint.position;
		}

		public DoorLock? GetDoorIfWantsToOpen()
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			Vector3 position = ((Component)NpcController.Npc.thisController).transform.position;
			DoorLock[] array = doorLocksArray;
			foreach (DoorLock val in array)
			{
				if ((Object)(object)val != (Object)null && !val.isLocked)
				{
					Vector3 val2 = ((Component)val).transform.position - position;
					if (((Vector3)(ref val2)).sqrMagnitude < 6.25f)
					{
						return val;
					}
				}
			}
			return null;
		}

		private bool OpenDoorIfNeeded()
		{
			if (timerCheckDoor > 0.9f)
			{
				timerCheckDoor = 0f;
				DoorLock doorIfWantsToOpen = GetDoorIfWantsToOpen();
				if ((Object)(object)doorIfWantsToOpen != (Object)null && !isDoorOpenedField.Invoke(doorIfWantsToOpen))
				{
					doorIfWantsToOpen.OpenOrCloseDoor(NpcController.Npc);
					return true;
				}
			}
			timerCheckDoor += base.AIIntervalTime;
			return false;
		}

		public DoorLock? UnlockDoorIfNeeded(float lockedDoorRange = 2.5f, bool checkLineOfSight = false, float proximityRange = -1f, bool bypassCooldown = false)
		{
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0133: Unknown result type (might be due to invalid IL or missing references)
			//IL_0138: Unknown result type (might be due to invalid IL or missing references)
			//IL_0142: Unknown result type (might be due to invalid IL or missing references)
			//IL_0147: Unknown result type (might be due to invalid IL or missing references)
			//IL_0164: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_019a: Unknown result type (might be due to invalid IL or missing references)
			if (bypassCooldown || Time.timeSinceLevelLoad - timerCheckLockedDoor > 0.9f)
			{
				timerCheckLockedDoor = Time.timeSinceLevelLoad;
				if (!HasKeyInInventory())
				{
					return null;
				}
				Vector3 position = ((Component)NpcController.Npc.thisController).transform.position;
				DoorLock[] array = doorLocksArray;
				RaycastHit val3 = default(RaycastHit);
				foreach (DoorLock val in array)
				{
					if (!val.isLocked || val.isPickingLock)
					{
						continue;
					}
					Vector3 val2 = ((Component)val).transform.position - position;
					float sqrMagnitude = ((Vector3)(ref val2)).sqrMagnitude;
					if (!(sqrMagnitude < lockedDoorRange * lockedDoorRange) || ((proximityRange < 0f || sqrMagnitude > proximityRange * proximityRange) && checkLineOfSight && Physics.Linecast(base.eye.position, ((Component)val).transform.position + Vector3.up * 0.2f, ref val3, StartOfRound.Instance.collidersAndRoomMaskAndDefault) && (Object)(object)((Component)((RaycastHit)(ref val3)).transform).gameObject.GetComponentInParent<DoorLock>() != (Object)(object)val && (Object)(object)((Component)((RaycastHit)(ref val3)).transform).gameObject.GetComponentInParent<TriggerPointToDoor>()?.pointToDoor != (Object)(object)val))
					{
						continue;
					}
					Vector3 offsetLockPickerPosition = GetOffsetLockPickerPosition(val);
					Vector3 offsetLockPickerPosition2 = GetOffsetLockPickerPosition(val, checkBack: true);
					float? num = null;
					float? num2 = null;
					Plugin.LogDebug("[UnlockDoorIfNeeded] Checking path to front of door!");
					if (IsValidPathToTarget(offsetLockPickerPosition, calculatePathDistance: true))
					{
						Plugin.LogDebug("[UnlockDoorIfNeeded] Successfuly found path to front of door!");
						num = base.pathDistance;
					}
					Plugin.LogDebug("[UnlockDoorIfNeeded] Checking path to back of door!");
					if (IsValidPathToTarget(offsetLockPickerPosition2, calculatePathDistance: true))
					{
						Plugin.LogDebug("[UnlockDoorIfNeeded] Successfuly found path to back of door!");
						num2 = base.pathDistance;
					}
					if (num.HasValue && num2.HasValue)
					{
						float num3 = ((!(num < num2)) ? (num.Value - num2.Value) : (num2.Value - num.Value));
						Plugin.LogDebug($"[UnlockDoorIfNeeded] Both sides to door {val} are pathable, distance between both sides {num3} meters!");
						if (num3 > 10f)
						{
							Plugin.LogDebug($"[UnlockDoorIfNeeded] Door {val} passed all checks and should be unlocked.");
							return val;
						}
					}
					else if (num.HasValue || num2.HasValue)
					{
						Plugin.LogDebug($"[UnlockDoorIfNeeded] Door {val} passed all checks and should be unlocked.");
						return val;
					}
				}
			}
			return null;
		}

		private void CheckIfLockedDoorsCanBeReached()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Expected O, but got Unknown
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: 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_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			//IL_0199: Unknown result type (might be due to invalid IL or missing references)
			//IL_019b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0283: Unknown result type (might be due to invalid IL or missing references)
			//IL_0288: Unknown result type (might be due to invalid IL or missing references)
			//IL_0292: Unknown result type (might be due to invalid IL or missing references)
			//IL_0297: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_012e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0138: Unknown result type (might be due to invalid IL or missing references)
			//IL_013f: Unknown result type (might be due to invalid IL or missing references)
			//IL_014a: Unknown result type (might be due to invalid IL or missing references)
			//IL_031b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0320: Unknown result type (might be due to invalid IL or missing references)
			//IL_032a: Unknown result type (might be due to invalid IL or missing references)
			//IL_032f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0345: Unknown result type (might be due to invalid IL or missing references)
			//IL_035b: Unknown result type (might be due to invalid IL or missing references)
			//IL_037b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01de: Unknown result type (might be due to invalid IL or missing references)
			//IL_0169: Unknown result type (might be due to invalid IL or missing references)
			//IL_0173: Unknown result type (might be due to invalid IL or missing references)
			//IL_0184: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0207: Unknown result type (might be due to invalid IL or missing references)
			//IL_0218: Unknown result type (might be due to invalid IL or missing references)
			NavMeshPath val = new NavMeshPath();
			List<Vector3> list = new List<Vector3>();
			EntranceTeleport[] entrancesTeleportArray = EntrancesTeleportArray;
			foreach (EntranceTeleport val2 in entrancesTeleportArray)
			{
				if (!val2.isEntranceToBuilding && val2.FindExitPoint())
				{
					list.Add(val2.entrancePoint.position);
				}
			}
			DoorLock[] array = doorLocksArray;
			foreach (DoorLock val3 in array)
			{
				Vector3? val4 = null;
				Vector3? val5 = null;
				if (!val3.isLocked)
				{
					continue;
				}
				foreach (Vector3 item in list)
				{
					NavMeshObstacle component = ((Component)val3).GetComponent<NavMeshObstacle>();
					Plugin.LogDebug($"Door blocker radius {component.radius}");
					Vector3 size = component.size;
					Plugin.LogDebug($"Door blocker size {((Vector3)(ref size)).magnitude}");
					Vector3 offsetLockPickerPosition = GetOffsetLockPickerPosition(val3);
					Vector3 offsetLockPickerPosition2 = GetOffsetLockPickerPosition(val3, checkBack: true);
					if (!val4.HasValue && NavMesh.CalculatePath(item, offsetLockPickerPosition, -1, val) && val != null && val.corners.Length != 0 && Vector3.Distance(val.corners[val.corners.Length - 1], RoundManager.Instance.GetNavMeshPosition(offsetLockPickerPosition, RoundManager.Instance.navHit, 2.7f, -1)) <= 1.5f)
					{
						Plugin.LogDebug($"Door {val3} can be reached! Door Pos: {((Component)val3).transform.position} Door Lock Pick Pos: {offsetLockPickerPosition}");
						val4 = offsetLockPickerPosition;
					}
					if (!val5.HasValue && NavMesh.CalculatePath(item, offsetLockPickerPosition2, -1, val) && val != null && val.corners.Length != 0 && Vector3.Distance(val.corners[val.corners.Length - 1], RoundManager.Instance.GetNavMeshPosition(offsetLockPickerPosition2, RoundManager.Instance.navHit, 2.7f, -1)) <= 1.5f)
					{
						Plugin.LogDebug($"Door {val3} can be reached! Door Pos: {((Component)val3).transform.position} Door Lock Pick Pos2: {offsetLockPickerPosition2}");
						val5 = offsetLockPickerPosition2;
					}
					if (val4.HasValue && val5.HasValue)
					{
						break;
					}
				}
				if (val4.HasValue || val5.HasValue)
				{
					if (val4.HasValue)
					{
						GameObject val6 = GameObject.CreatePrimitive((PrimitiveType)0);
						val6.transform.position = val4.Value + Vector3.up * 0.2f;
						val6.GetComponent<Renderer>().material.color = Color.green;
						GameNetworkManager.Instance.localPlayerController.TeleportPlayer(val4.Value, false, 0f, false, true);
						Plugin.LogDebug($"Door {val3} can be reached! Door Pos: {((Component)val3).transform.position} Door Lock Pick Pos: {val4}");
					}
					if (val5.HasValue)
					{
						GameObject val7 = GameObject.CreatePrimitive((PrimitiveType)0);
						val7.transform.position = val5.Value + Vector3.up * 0.2f;
						val7.GetComponent<Renderer>().material.color = Color.cyan;
						GameNetworkManager.Instance.localPlayerController.TeleportPlayer(val5.Value, false, 0f, false, true);
						Plugin.LogDebug($"Door {val3} can be reached! Door Pos: {((Component)val3).transform.position} Door Lock Pick Pos2: {val5}");
					}
				}
				else
				{
					Plugin.LogDebug("[WARNING] Bot was unable to reach door!");
				}
			}
		}

		public static Vector3 GetOffsetLockPickerPosition(DoorLock doorScript, bool checkBack = false, float offsetDistance = 1.5f, int areaMask = -1)
		{
			//IL_0006: 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_001b: 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_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = ((Component)doorScript).transform.position + ((Component)doorScript).transform.right;
			Vector3 val2 = ((Component)doorScript).transform.position - ((Component)doorScript).transform.right;
			Vector3 val3;
			Vector3 normalized;
			if (!checkBack)
			{
				val3 = val2 - val;
				normalized = ((Vector3)(ref val3)).normalized;
			}
			else
			{
				val3 = val - val2;
				normalized = ((Vector3)(ref val3)).normalized;
			}
			Vector3 val4 = normalized;
			Vector3 val5 = ((Component)doorScript).transform.position + val4 * offsetDistance;
			return RoundManager.Instance.GetNavMeshPosition(val5, RoundManager.Instance.navHit, 3f, areaMask);
		}

		public bool UseElevator(bool goUp)
		{
			//IL_0035: 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_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0126: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_014c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0151: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bd: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)ElevatorScript == (Object)null || base.isOutside)
			{
				return false;
			}
			Vector3 val = ((!goUp) ? ElevatorScript.elevatorTopPoint.position : ElevatorScript.elevatorBottomPoint.position);
			float num = Vector3.Distance(((Component)NpcController.Npc).transform.position, ElevatorScript.elevatorInsidePoint.position);
			if (ElevatorScript.elevatorFinishedMoving && (num <= 1f || IsValidPathToTarget(ElevatorScript.elevatorInsidePoint.position)))
			{
				if (num <= 1f && ElevatorScript.elevatorMovingDown == goUp && timerElevatorCooldown > 4f && Time.timeSinceLevelLoad - pressElevatorButtonCooldown > base.AIIntervalTime + 0.16f)
				{
					pressElevatorButtonCooldown = Time.timeSinceLevelLoad;
					ElevatorScript.PressElevatorButton();
				}
				if (num > 1f)
				{
					SetDestinationToPositionLethalBotAI(ElevatorScript.elevatorInsidePoint.position);
					OrderMoveToDestination();
				}
				else
				{
					StopMoving();
				}
				return true;
			}
			if (num > 1f && IsValidPathToTarget(val))
			{
				float num2 = Vector3.Distance(((Component)NpcController.Npc).transform.position, val);
				if (num2 <= 1f && ElevatorScript.elevatorMovingDown != goUp && !ElevatorScript.elevatorCalled && timerElevatorCooldown > 4f && Time.timeSinceLevelLoad - pressElevatorButtonCooldown > base.AIIntervalTime + 0.16f)
				{
					pressElevatorButtonCooldown = Time.timeSinceLevelLoad;
					ElevatorScript.CallElevator(goUp);
				}
				if (num2 > 1f)
				{
					SetDestinationToPositionLethalBotAI(val);
					OrderMoveToDestination();
				}
				else
				{
					StopMoving();
				}
				return true;
			}
			return false;
		}

		public bool IsPlayerNearElevatorEntrance(PlayerControllerB player)
		{
			//IL_003b: 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_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)ElevatorScript == (Object)null)
			{
				return false;
			}
			LethalBotAI lethalBotAIIfLocalIsOwner = LethalBotManager.Instance.GetLethalBotAIIfLocalIsOwner(player);
			if ((Object)(object)lethalBotAIIfLocalIsOwner != (Object)null)
			{
				return lethalBotAIIfLocalIsOwner.IsInElevatorStartRoom;
			}
			if (!player.isInsideFactory)
			{
				return false;
			}
			if (Vector3.Distance(((Component)player).transform.position, ElevatorScript.elevatorBottomPoint.position) < 10f)
			{
				return false;
			}
			if (Vector3.Distance(((Component)player).transform.position, ElevatorScript.elevatorTopPoint.position) < 20f)
			{
				return true;
			}
			return false;
		}

		public bool IsPositionNearElevatorEntrance(Vector3 position)
		{
			//IL_000d: 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_002b: 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)
			if ((Object)(object)ElevatorScript != (Object)null)
			{
				if (Vector3.Distance(position, ElevatorScript.elevatorBottomPoint.position) < 10f)
				{
					return false;
				}
				if (Vector3.Distance(position, ElevatorScript.elevatorTopPoint.position) < 20f)
				{
					return true;
				}
			}
			return false;
		}

		private bool UseLadderIfNeeded()
		{
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0117: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			if (NpcController.Npc.isClimbingLadder || useLadderCoroutine != null)
			{
				return true;
			}
			InteractTrigger ladderIfWantsToUseLadder = GetLadderIfWantsToUseLadder();
			if ((Object)(object)ladderIfWantsToUseLadder == (Object)null)
			{
				if (base.agent.isOnOffMeshLink && offMeshLinkCoroutine == null)
				{
					offMeshLinkCoroutine = ((MonoBehaviour)this).StartCoroutine(offMeshLinkParabola(base.agent, 0.6f));
				}
				return false;
			}
			if (Plugin.Config.TeleportWhenUsingLadders.Value)
			{
				if (base.agent.isOnOffMeshLink)
				{
					OffMeshLinkData currentOffMeshLinkData = base.agent.currentOffMeshLinkData;
					TeleportLethalBot(((OffMeshLinkData)(ref currentOffMeshLinkData)).endPos, base.isOutside);
					base.agent.CompleteOffMeshLink();
				}
				return true;
			}
			if (NpcController.CanUseLadder(ladderIfWantsToUseLadder))
			{
				ladderIfWantsToUseLadder.Interact(NpcController.Npc.thisPlayerBody);
				((Component)NpcController.Npc).transform.rotation = ((Component)ladderIfWantsToUseLadder.ladderPlayerPositionNode).transform.rotation;
				NpcController.SetTurnBodyTowardsDirection(((Component)NpcController.Npc).transform.forward);
			}
			else
			{
				StopMoving();
			}
			return true;
		}

		[IteratorStateMachine(typeof(<autoTraverseOffMeshLink>d__143))]
		private IEnumerator autoTraverseOffMeshLink()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <autoTraverseOffMeshLink>d__143(0)
			{
				<>4__this = this
			};
		}

		public bool IsUsingOffMeshLink()
		{
			if (offMeshLinkCoroutine == null)
			{
				return base.agent.isOnOffMeshLink;
			}
			return true;
		}

		[IteratorStateMachine(typeof(<offMeshLinkParabola>d__145))]
		private IEnumerator offMeshLinkParabola(NavMeshAgent agent, float height)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <offMeshLinkParabola>d__145(0)
			{
				<>4__this = this,
				agent = agent,
				height = height
			};
		}

		public void StopOffMeshLinkMovement(bool warpToEnd = true)
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: 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_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			if (offMeshLinkCoroutine == null)
			{
				return;
			}
			((MonoBehaviour)this).StopCoroutine(offMeshLinkCoroutine);
			offMeshLinkCoroutine = null;
			OffMeshLinkData currentOffMeshLinkData = base.agent.currentOffMeshLinkData;
			base.agent.CompleteOffMeshLink();
			if (((OffMeshLinkData)(ref currentOffMeshLinkData)).valid)
			{
				Plugin.LogDebug($"Completed off mesh EARLY link due to an interruption; position: {((Component)this).transform.position}");
				if (Vector3.Distance(((Component)this).transform.position, ((OffMeshLinkData)(ref currentOffMeshLinkData)).startPos) < Vector3.Distance(((Component)this).transform.position, ((OffMeshLinkData)(ref currentOffMeshLinkData)).endPos))
				{
					Plugin.LogDebug($"Warping agent to start position at {((OffMeshLinkData)(ref currentOffMeshLinkData)).startPos}");
					if (warpToEnd)
					{
						TeleportAgentAIAndBody(((OffMeshLinkData)(ref currentOffMeshLinkData)).startPos);
					}
				}
				else
				{
					Plugin.LogDebug($"Warping agent to end position at {((OffMeshLinkData)(ref currentOffMeshLinkData)).endPos}");
					if (warpToEnd)
					{
						TeleportAgentAIAndBody(((OffMeshLinkData)(ref currentOffMeshLinkData)).endPos);
					}
				}
			}
			else
			{
				Plugin.LogDebug("Off mesh link data invalid; agent completing off mesh link anyway");
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[MemberNotNullWhen(false, "HeldItem")]
		public bool AreHandsFree()
		{
			return (Object)(object)HeldItem == (Object)null;
		}

		[MemberNotNullWhen(true, "HeldItem")]
		public bool IsHoldingCombatWeapon()
		{
			if (!HasAmmoForWeapon(HeldItem))
			{
				return false;
			}
			return IsItemWeapon(HeldItem);
		}

		[MemberNotNullWhen(true, "HeldItem")]
		public bool IsHoldingRangedWeapon()
		{
			if (!HasAmmoForWeapon(HeldItem))
			{
				return false;
			}
			return IsItemRangedWeapon(HeldItem);
		}

		[MemberNotNullWhen(true, "HeldItem")]
		public bool IsHoldingKey(bool keyOnly = false)
		{
			return IsItemKey(HeldItem, keyOnly);
		}

		public bool HasCombatWeapon()
		{
			if (IsHoldingCombatWeapon())
			{
				return true;
			}
			GrabbableObject itemOnlySlot = NpcController.Npc.ItemOnlySlot;
			if ((Object)(object)itemOnlySlot != (Object)null && HasAmmoForWeapon(itemOnlySlot))
			{
				return true;
			}
			GrabbableObject[] itemSlots = NpcController.Npc.ItemSlots;
			foreach (GrabbableObject weapon in itemSlots)
			{
				if (HasAmmoForWeapon(weapon))
				{
					return true;
				}
			}
			return false;
		}

		public bool HasRangedWeapon()
		{
			if (IsHoldingRangedWeapon())
			{
				return true;
			}
			GrabbableObject itemOnlySlot = NpcController.Npc.ItemOnlySlot;
			if ((Object)(object)itemOnlySlot != (Object)null && HasAmmoForWeapon(itemOnlySlot) && IsItemRangedWeapon(itemOnlySlot))
			{
				return true;
			}
			GrabbableObject[] itemSlots = NpcController.Npc.ItemSlots;
			foreach (GrabbableObject weapon in itemSlots)
			{
				if (HasAmmoForWeapon(weapon) && IsItemRangedWeapon(weapon))
				{
					return true;
				}
			}
			return false;
		}

		public bool HasKeyInInventory(bool keyOnly = false)
		{
			if (IsHoldingKey(keyOnly))
			{
				return true;
			}
			GrabbableObject itemOnlySlot = NpcController.Npc.ItemOnlySlot;
			if (IsItemKey(itemOnlySlot, keyOnly))
			{
				return true;
			}
			GrabbableObject[] itemSlots = NpcController.Npc.ItemSlots;
			foreach (GrabbableObject item in itemSlots)
			{
				if (IsItemKey(item, keyOnly))
				{
					return true;
				}
			}
			return false;
		}

		public static bool IsItemRangedWeapon([NotNullWhen(true)] GrabbableObject? weapon)
		{
			if ((Object)(object)weapon == (Object)null)
			{
				return false;
			}
			if (!(weapon is ShotgunItem))
			{
				return weapon is PatcherTool;
			}
			return true;
		}

		public static bool IsItemWeapon([NotNullWhen(true)] GrabbableObject? weapon)
		{
			if ((Object)(object)weapon == (Object)null)
			{
				return false;
			}
			if (IsItemRangedWeapon(weapon))
			{
				return true;
			}
			if (!(weapon is Shovel))
			{
				return weapon is KnifeItem;
			}
			return true;
		}

		public static bool IsItemScrap([NotNullWhen(true)] GrabbableObject? item)
		{
			if ((Object)(object)item == (Object)null)
			{
				return false;
			}
			if (item.itemProperties.isScrap)
			{
				return item.scrapValue > 0;
			}
			return false;
		}

		public static bool IsItemKey([NotNullWhen(true)] GrabbableObject? item, bool keyOnly = false)
		{
			if ((Object)(object)item == (Object)null)
			{
				return false;
			}
			if (item is KeyItem)
			{
				return true;
			}
			if (!keyOnly)
			{
				return item is LockPicker;
			}
			return false;
		}

		public static bool IsItemPowered([NotNullWhen(true)] GrabbableObject? item)
		{
			if ((Object)(object)item == (Object)null)
			{
				return false;
			}
			if (!item.itemProperties.requiresBattery)
			{
				return true;
			}
			if (item.insertedBattery == null || item.insertedBattery.empty)
			{
				return false;
			}
			return true;
		}

		public bool HasAmmoForWeapon([NotNullWhen(true)] GrabbableObject? weapon, bool spareOnly = false)
		{
			if (!IsItemWeapon(weapon))
			{
				return false;
			}
			if (!IsItemPowered(weapon))
			{
				return false;
			}
			ShotgunItem val = (ShotgunItem)(object)((weapon is ShotgunItem) ? weapon : null);
			if (val != null)
			{
				if (!spareOnly && val.shellsLoaded > 0)
				{
					return true;
				}
				GrabbableObject itemOnlySlot = NpcController.Npc.ItemOnlySlot;
				if ((Object)(object)itemOnlySlot != (Object)null)
				{
					GunAmmo val2 = (GunAmmo)(object)((itemOnlySlot is GunAmmo) ? itemOnlySlot : null);
					if ((Object)(object)val2 != (Object)null && val2.ammoType == val.gunCompatibleAmmoID)
					{
						return true;
					}
				}
				int num = 0;
				GrabbableObject[] itemSlots = NpcController.Npc.ItemSlots;
				foreach (GrabbableObject val3 in itemSlots)
				{
					if ((Object)(object)val3 != (Object)null)
					{
						GunAmmo val4 = (GunAmmo)(object)((val3 is GunAmmo) ? val3 : null);
						Plugin.LogDebug($"Ammo null in slot #{num}?: {(Object)(object)val4 == (Object)null}");
						if ((Object)(object)val4 != (Object)null)
						{
							Plugin.LogDebug($"Ammo in slot #{num} id: {val4.ammoType}");
						}
						if ((Object)(object)val4 != (Object)null && val4.ammoType == val.gunCompatibleAmmoID)
						{
							return true;
						}
					}
					num++;
				}
				return false;
			}
			return true;
		}

		public bool HasGrabbableObjectInInventory([NotNullWhen(true)] GrabbableObject? grabbableObject, out int objectSlot)
		{
			objectSlot = -1;
			if ((Object)(object)grabbableObject == (Object)null)
			{
				return false;
			}
			if ((Object)(object)HeldItem == (Object)(object)grabbableObject)
			{
				objectSlot = NpcController.Npc.currentItemSlot;
				return true;
			}
			GrabbableObject itemOnlySlot = NpcController.Npc.ItemOnlySlot;
			if ((Object)(object)itemOnlySlot == (Object)(object)grabbableObject)
			{
				objectSlot = 50;
				return true;
			}
			int num = 0;
			GrabbableObject[] itemSlots = NpcController.Npc.ItemSlots;
			foreach (GrabbableObject val in itemSlots)
			{
				if ((Object)(object)val == (Object)(object)grabbableObject)
				{
					objectSlot = num;
					return true;
				}
				num++;
			}
			return false;
		}

		public bool HasGrabbableObjectInInventory(Type typeOfObject, out int objectSlot)
		{
			objectSlot = -1;
			if (typeOfObject.IsInstanceOfType(HeldItem))
			{
				objectSlot = NpcController.Npc.currentItemSlot;
				return true;
			}
			GrabbableObject itemOnlySlot = NpcController.Npc.ItemOnlySlot;
			if ((Object)(object)itemOnlySlot != (Object)null && typeOfObject.IsInstanceOfType(itemOnlySlot))
			{
				objectSlot = 50;
				return true;
			}
			int num = 0;
			GrabbableObject[] itemSlots = NpcController.Npc.ItemSlots;
			foreach (GrabbableObject o in itemSlots)
			{
				if (typeOfObject.IsInstanceOfType(o))
				{
					objectSlot = num;
					return true;
				}
				num++;
			}
			return false;
		}

		public bool HasGrabbableObjectInInventory(Func<GrabbableObject, bool> objectPredicate, out int objectSlot)
		{
			objectSlot = -1;
			if (!AreHandsFree() && objectPredicate(HeldItem))
			{
				objectSlot = NpcController.Npc.currentItemSlot;
				return true;
			}
			GrabbableObject itemOnlySlot = NpcController.Npc.ItemOnlySlot;
			if ((Object)(object)itemOnlySlot != (Object)null && objectPredicate(itemOnlySlot))
			{
				objectSlot = 50;
				return true;
			}
			int num = 0;
			GrabbableObject[] itemSlots = NpcController.Npc.ItemSlots;
			foreach (GrabbableObject val in itemSlots)
			{
				if ((Object)(object)val != (Object)null && objectPredicate(val))
				{
					objectSlot = num;
					return true;
				}
				num++;
			}
			return false;
		}

		public bool TryFindItemInInventory(Func<GrabbableObject, bool> filter, Func<GrabbableObject, GrabbableObject, bool> isBetter, out int objectSlot)
		{
			objectSlot = -1;
			GrabbableObject val = null;
			GrabbableObject itemOnlySlot = NpcController.Npc.ItemOnlySlot;
			if ((Object)(object)itemOnlySlot != (Object)null && filter(itemOnlySlot))
			{
				val = itemOnlySlot;
				objectSlot = 50;
			}
			int num = 0;
			GrabbableObject[] itemSlots = NpcController.Npc.ItemSlots;
			foreach (GrabbableObject val2 in itemSlots)
			{
				if ((Object)(object)val2 != (Object)null && filter(val2) && ((Object)(object)val == (Object)null || isBetter(val, val2)))
				{
					val = val2;
					objectSlot = num;
				}
				num++;
			}
			return (Object)(object)val != (Object)null;
		}

		public GrabbableObject? GetItemAtSlot(int slot, PlayerControllerB? lethalBotController = null, GrabbableObject[]? itemSlots = null)
		{
			if (lethalBotController == null)
			{
				lethalBotController = NpcController.Npc;
			}
			if (slot == 50)
			{
				return lethalBotController.ItemOnlySlot;
			}
			if (itemSlots == null)
			{
				itemSlots = lethalBotController.ItemSlots;
			}
			if (slot < 0 || slot >= itemSlots.Length)
			{
				Plugin.LogWarning($"LethalBotAI.GetItemAtSlot was given a slot out of range {slot}. Returning null!");
				return null;
			}
			return itemSlots[slot];
		}

		public bool HasSpaceInInventory()
		{
			GrabbableObject[] itemSlots = NpcController.Npc.ItemSlots;
			int inventorySize = GetInventorySize(NpcController.Npc, itemSlots);
			for (int i = 0; i < inventorySize; i++)
			{
				GrabbableObject val = itemSlots[i];
				if ((Object)(object)val == (Object)null)
				{
					return true;
				}
			}
			return false;
		}

		public bool HasSpaceInInventory(GrabbableObject? grabbableObject)
		{
			return FirstEmptyItemSlot(grabbableObject) != -1;
		}

		public bool HasSomethingInInventory()
		{
			if (!AreHandsFree())
			{
				return true;
			}
			GrabbableObject itemOnlySlot = NpcController.Npc.ItemOnlySlot;
			if ((Object)(object)itemOnlySlot != (Object)null)
			{
				return true;
			}
			GrabbableObject[] itemSlots = NpcController.Npc.ItemSlots;
			foreach (GrabbableObject val in itemSlots)
			{
				if ((Object)(object)val != (Object)null)
				{
					return true;
				}
			}
			return false;
		}

		public bool HasScrapInInventory()
		{
			if (!AreHandsFree() && IsItemScrap(HeldItem) && !IsGrabbableObjectInLoadout(HeldItem))
			{
				return true;
			}
			GrabbableObject itemOnlySlot = NpcController.Npc.ItemOnlySlot;
			if ((Object)(object)itemOnlySlot != (Object)null && IsItemScrap(itemOnlySlot) && !IsGrabbableObjectInLoadout(itemOnlySlot))
			{
				return true;
			}
			GrabbableObject[] itemSlots = NpcController.Npc.ItemSlots;
			foreach (GrabbableObject val in itemSlots)
			{
				if (IsItemScrap(val) && !IsGrabbableObjectInLoadout(val))
				{
					return true;
				}
			}
			return false;
		}

		public bool HasSellableItemInInventory()
		{
			if (!AreHandsFree() && IsGrabbableObjectSellable(HeldItem, ignoreHeldFlag: true, skipPathCheck: true))
			{
				return true;
			}
			GrabbableObject itemOnlySlot = NpcController.Npc.ItemOnlySlot;
			if ((Object)(object)itemOnlySlot != (Object)null && IsGrabbableObjectSellable(itemOnlySlot, ignoreHeldFlag: true, skipPathCheck: true))
			{
				return true;
			}
			GrabbableObject[] itemSlots = NpcController.Npc.ItemSlots;
			foreach (GrabbableObject val in itemSlots)
			{
				if ((Object)(object)val != (Object)null && IsGrabbableObjectSellable(val, ignoreHeldFlag: true, skipPathCheck: true))
				{
					return true;
				}
			}
			return false;
		}

		public bool HasDuplicateLoadoutItems(GrabbableObject grabbableObject, out int objectSlot)
		{
			objectSlot = -1;
			if (!IsGrabbableObjectInLoadout(grabbableObject))
			{
				return false;
			}
			if (HasGrabbableObjectInInventory(grabbableObject, out var objectSlot2))
			{
				GrabbableObject itemOnlySlot = NpcController.Npc.ItemOnlySlot;
				if ((Object)(object)itemOnlySlot != (Object)null && objectSlot2 != 50 && itemOnlySlot.itemProperties.itemName == grabbableObject.itemProperties.itemName)
				{
					objectSlot = 50;
					return true;
				}
				GrabbableObject[] itemSlots = NpcController.Npc.ItemSlots;
				for (int i = 0; i < itemSlots.Length; i++)
				{
					if (i != objectSlot2)
					{
						GrabbableObject val = itemSlots[i];
						if ((Object)(object)val != (Object)null && val.itemProperties.itemName == grabbableObject.itemProperties.itemName)
						{
							objectSlot = i;
							return true;
						}
					}
				}
			}
			else
			{
				Plugin.LogWarning($"HasDuplicateLoadoutItems was called with a grabbable object \"{grabbableObject}\" not in the bot's inventory!");
			}
			return false;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public bool IsGrabbableObjectInLoadout([NotNullWhen(true)] GrabbableObject grabbableObject)
		{
			return LethalBotIdentity.Loadout.IsGrabbableObjectInLoadout(grabbableObject);
		}

		[MemberNotNullWhen(true, "HeldItem")]
		public bool CanUseHeldItem()
		{
			PlayerControllerB npc = NpcController.Npc;
			if (!((NetworkBehaviour)this).IsOwner || !npc.isPlayerControlled)
			{
				return false;
			}
			if (AreHandsFree())
			{
				return false;
			}
			if (npc.isPlayerDead)
			{
				return false;
			}
			if (!HeldItem.itemProperties.usableInSpecialAnimations && (npc.isGrabbingObjectAnimation || npc.inTerminalMenu || npc.isTypingChat || (npc.inSpecialInteractAnimation && !npc.inShockingMinigame)))
			{
				return false;
			}
			return true;
		}

		public bool TurnOffHeldItem()
		{
			GrabbableObject heldItem = HeldItem;
			if ((Object)(object)heldItem == (Object)null)
			{
				return false;
			}
			FlashlightItem val = (FlashlightItem)(object)((heldItem is FlashlightItem) ? heldItem : null);
			if (val != null && ((GrabbableObject)val).isBeingUsed)
			{
				((GrabbableObject)val).UseItemOnClient(true);
				if (((GrabbableObject)val).itemProperties.holdButtonUse)
				{
					((GrabbableObject)val).UseItemOnClient(false);
				}
				return true;
			}
			WalkieTalkie val2 = (WalkieTalkie)(object)((heldItem is WalkieTalkie) ? heldItem : null);
			if (val2 != null && ((GrabbableObject)val2).isBeingUsed)
			{
				if (!val2.isHoldingButton)
				{
					((GrabbableObject)val2).ItemInteractLeftRightOnClient(false);
				}
				return true;
			}
			return false;
		}

		[ServerRpc(RequireOwnership = false)]
		public void ChangeOwnershipOfBotInventoryServerRpc(ulong newOwnerClientId)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				ServerRpcParams val = default(ServerRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(2943335133u, val, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val2, newOwnerClientId);
				((NetworkBehaviour)this).__endSendServerRpc(ref val2, 2943335133u, val, (RpcDelivery)0);
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 || (!networkManager.IsServer && !networkManager.IsHost))
			{
				return;
			}
			((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
			GrabbableObject[] itemSlots = NpcController.Npc.ItemSlots;
			foreach (GrabbableObject val3 in itemSlots)
			{
				NetworkObject val4 = ((val3 != null) ? ((NetworkBehaviour)val3).NetworkObject : null);
				if ((Object)(object)val4 != (Object)null && val4.OwnerClientId != newOwnerClientId)
				{
					val4.ChangeOwnership(newOwnerClientId);
				}
			}
			GrabbableObject itemOnlySlot = NpcController.Npc.ItemOnlySlot;
			if ((Object)(object)itemOnlySlot != (Object)null)
			{
				NetworkObject networkObject = ((NetworkBehaviour)itemOnlySlot).NetworkObject;
				if ((Object)(object)networkObject != (Object)null && networkObject.OwnerClientId != newOwnerClientId)
				{
					networkObject.ChangeOwnership(newOwnerClientId);
				}
			}
		}

		public void UpdateOwnershipOfBotServer()
		{
			if (!((NetworkBehaviour)this).IsServer && !((NetworkBehaviour)this).IsHost)
			{
				ChangeOwnershipOfBotInventoryServerRpc(((NetworkBehaviour)this).OwnerClientId);
				ChangeNpcOwnershipOfBotServerRpc(((NetworkBehaviour)this).OwnerClientId);
				if (Plugin.IsModLethalPhonesLoaded)
				{
					ChangeOwnershipOfLethalPhoneServerRpc(((NetworkBehaviour)this).OwnerClientId);
				}
				return;
			}
			GrabbableObject[] itemSlots = NpcController.Npc.ItemSlots;
			foreach (GrabbableObject val in itemSlots)
			{
				NetworkObject val2 = ((val != null) ? ((NetworkBehaviour)val).NetworkObject : null);
				if ((Object)(object)val2 != (Object)null && val2.OwnerClientId != ((NetworkBehaviour)this).OwnerClientId)
				{
					val2.ChangeOwnership(((NetworkBehaviour)this).OwnerClientId);
				}
			}
			GrabbableObject itemOnlySlot = NpcController.Npc.ItemOnlySlot;
			if ((Object)(object)itemOnlySlot != (Object)null)
			{
				NetworkObject networkObject = ((NetworkBehaviour)itemOnlySlot).NetworkObject;
				if ((Object)(object)networkObject != (Object)null && networkObject.OwnerClientId != ((NetworkBehaviour)this).OwnerClientId)
				{
					networkObject.ChangeOwnership(((NetworkBehaviour)this).OwnerClientId);
				}
			}
			NetworkObject component = ((Component)NpcController.Npc).gameObject.GetComponent<NetworkObject>();
			if ((Object)(object)component != (Object)null && component.OwnerClientId != ((NetworkBehaviour)this).OwnerClientId)
			{
				component.ChangeOwnership(((NetworkBehaviour)this).OwnerClientId);
			}
			if (Plugin.IsModLethalPhonesLoaded)
			{
				UpdateLethalPhoneOwnership();
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void ChangeNpcOwnershipOfBotServerRpc(ulong newOwnerClientId)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				ServerRpcParams val = default(ServerRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(177443032u, val, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val2, newOwnerClientId);
				((NetworkBehaviour)this).__endSendServerRpc(ref val2, 177443032u, val, (RpcDelivery)0);
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
				NetworkObject component = ((Component)NpcController.Npc).gameObject.GetComponent<NetworkObject>();
				if ((Object)(object)component != (Object)null && component.OwnerClientId != newOwnerClientId)
				{
					component.ChangeOwnership(newOwnerClientId);
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void ChangeOwnershipOfLethalPhoneServerRpc(ulong newOwnerClientId)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				ServerRpcParams val = default(ServerRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(1460449774u, val, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val2, newOwnerClientId);
				((NetworkBehaviour)this).__endSendServerRpc(ref val2, 1460449774u, val, (RpcDelivery)0);
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 || (!networkManager.IsServer && !networkManager.IsHost))
			{
				return;
			}
			((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
			PlayerPhone ourPlayerPhone = GetOurPlayerPhone();
			if ((Object)(object)ourPlayerPhone != (Object)null)
			{
				NetworkObject component = ((Component)ourPlayerPhone).GetComponent<NetworkObject>();
				if ((Object)(object)component != (Object)null && component.OwnerClientId != newOwnerClientId)
				{
					component.ChangeOwnership(newOwnerClientId);
					StopLethalPhonesCoroutine();
				}
			}
		}

		private void UpdateLethalPhoneOwnership()
		{
			PlayerPhone ourPlayerPhone = GetOurPlayerPhone();
			if ((Object)(object)ourPlayerPhone != (Object)null)
			{
				NetworkObject component = ((Component)ourPlayerPhone).GetComponent<NetworkObject>();
				if ((Object)(object)component != (Object)null && component.OwnerClientId != ((NetworkBehaviour)this).OwnerClientId)
				{
					component.ChangeOwnership(((NetworkBehaviour)this).OwnerClientId);
					StopLethalPhonesCoroutine();
				}
			}
		}

		public GrabbableObject? LookingForObjectToGrab()
		{
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_016d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0179: Unknown result type (might be due to invalid IL or missing references)
			//IL_017e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0188: Unknown result type (might be due to invalid IL or missing references)
			//IL_018d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c2: Unknown result type (might be due to invalid IL or missing references)
			GrabbableObject result = null;
			float num = float.MaxValue;
			for (int i = 0; i < LethalBotManager.grabbableObjectsInMap.Count; i++)
			{
				GameObject val = LethalBotManager.grabbableObjectsInMap[i];
				if ((Object)(object)val == (Object)null)
				{
					LethalBotManager.grabbableObjectsInMap.TrimExcess();
					continue;
				}
				Vector3 position = val.transform.position;
				if ((base.isOutside && position.y < -100f) || (!base.isOutside && position.y > -80f))
				{
					continue;
				}
				Vector3 val2 = position - base.eye.position;
				float sqrMagnitude = ((Vector3)(ref val2)).sqrMagnitude;
				if (sqrMagnitude > 225f || sqrMagnitude > num)
				{
					continue;
				}
				GrabbableObject component = val.GetComponent<GrabbableObject>();
				if ((Object)(object)component == (Object)null || IsGrabbableObjectBlackListed(component) || component.isInElevator || component.isInShipRoom || ((Object)(object)((Component)component).transform.parent != (Object)null && ((Object)((Component)component).transform.parent).name.StartsWith("CompanyCruiser")) || (Plugin.IsModCustomItemBehaviourLibraryLoaded && IsGrabbableObjectInContainerMod(component)) || (Plugin.IsModLethalMinLoaded && IsGrabbableObjectHeldByPikminMod(component)) || !IsGrabbableObjectGrabbable(component))
				{
					continue;
				}
				if (sqrMagnitude < 16f)
				{
					Plugin.LogDebug("awareness " + ((Object)component).name);
				}
				else
				{
					if (Physics.Linecast(base.eye.position, ((Component)component).transform.position + Vector3.up * 0.05f, StartOfRound.Instance.collidersAndRoomMaskAndDefault))
					{
						continue;
					}
					Vector3 val3 = position - base.eye.position;
					if (!(Vector3.Angle(base.eye.forward, val3) < 90f))
					{
						continue;
					}
					Plugin.LogDebug("LOS " + ((Object)component).name);
				}
				result = component;
				num = sqrMagnitude;
			}
			return result;
		}

		public GrabbableObject? LookingForObjectsToSell(bool ignoreHeldFlag = false)
		{
			//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_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: 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)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			if (LethalBotManager.HaveWeFulfilledTheProfitQuota())
			{
				return null;
			}
			Vector3 position = ((Component)NpcController.Npc).transform.position;
			GrabbableObject result = null;
			float num = float.MaxValue;
			int num2 = int.MaxValue;
			for (int i = 0; i < LethalBotManager.grabbableObjectsInMap.Count; i++)
			{
				GameObject val = LethalBotManager.grabbableObjectsInMap[i];
				if ((Object)(object)val == (Object)null)
				{
					LethalBotManager.grabbableObjectsInMap.TrimExcess();
					continue;
				}
				Vector3 position2 = val.transform.position;
				if ((base.isOutside && position2.y < -100f) || (!base.isOutside && position2.y > -80f))
				{
					continue;
				}
				GrabbableObject component = val.GetComponent<GrabbableObject>();
				if ((Object)(object)component == (Object)null || IsGrabbableObjectBlackListed(component, EnumGrabbableObjectCall.Selling))
				{
					continue;
				}
				if (!Plugin.Config.SellAllScrapOnShip.Value)
				{
					if (num2 < component.scrapValue)
					{
						continue;
					}
					if (num2 != component.scrapValue)
					{
						num = float.MaxValue;
					}
				}
				Vector3 val2 = position2 - position;
				float sqrMagnitude = ((Vector3)(ref val2)).sqrMagnitude;
				if (!(sqrMagnitude > num) && (!Plugin.IsModCustomItemBehaviourLibraryLoaded || !IsGrabbableObjectInContainerMod(component)) && (!Plugin.IsModLethalMinLoaded || !IsGrabbableObjectHeldByPikminMod(component)) && IsGrabbableObjectSellable(component, ignoreHeldFlag))
				{
					result = component;
					num = sqrMagnitude;
					num2 = component.scrapValue;
				}
			}
			return result;
		}

		public PlayerControllerB? LookingForPlayerToRevive(bool ignoreLOS = false, bool shipOnly = false)
		{
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0196: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01de: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01eb: Unknown result type (might be due to invalid IL or missing references)
			if (!RescueAndReviveState.IsAnyReviveModInstalled())
			{
				return null;
			}
			PlayerControllerB result = null;
			float num = float.MaxValue;
			for (int i = 0; i < LethalBotManager.grabbableObjectsInMap.Count; i++)
			{
				GameObject val = LethalBotManager.grabbableObjectsInMap[i];
				if ((Object)(object)val == (Object)null)
				{
					LethalBotManager.grabbableObjectsInMap.TrimExcess();
					continue;
				}
				GrabbableObject component = val.GetComponent<GrabbableObject>();
				RagdollGrabbableObject val2 = (RagdollGrabbableObject)(object)((component is RagdollGrabbableObject) ? component : null);
				if (val2 == null)
				{
					continue;
				}
				bool isHeld = component.isHeld;
				Vector3 position = val.transform.position;
				if (!isHeld && ((base.isOutside && position.y < -100f) || (!base.isOutside && position.y > -80f)))
				{
					continue;
				}
				Vector3 val3 = position - base.eye.position;
				float sqrMagnitude = ((Vector3)(ref val3)).sqrMagnitude;
				if ((!isHeld && sqrMagnitude > 900f) || sqrMagnitude > num)
				{
					continue;
				}
				PlayerControllerB val4 = StartOfRound.Instance.allPlayerScripts[val2.bodyID];
				if ((Object)(object)val4 == (Object)null || !RescueAndReviveState.CanRevivePlayer(this, val4) || IsGrabbableObjectBlackListed(component, EnumGrabbableObjectCall.Reviving) || (shipOnly && !isHeld && !component.isInElevator && !component.isInShipRoom) || (Plugin.IsModCustomItemBehaviourLibraryLoaded && IsGrabbableObjectInContainerMod(component)) || (Plugin.IsModLethalMinLoaded && IsGrabbableObjectHeldByPikminMod(component)) || !IsGrabbableObjectGrabbable(component, EnumGrabbableObjectCall.Reviving))
				{
					continue;
				}
				if (!ignoreLOS)
				{
					if (isHeld || sqrMagnitude < 16f)
					{
						Plugin.LogDebug("awareness " + ((Object)component).name);
					}
					else
					{
						if (Physics.Linecast(base.eye.position, ((Component)component).transform.position + Vector3.up * 0.05f, StartOfRound.Instance.collidersAndRoomMaskAndDefault))
						{
							continue;
						}
						Vector3 val5 = position - base.eye.position;
						if (!(Vector3.Angle(base.eye.forward, val5) < 90f))
						{
							continue;
						}
						Plugin.LogDebug("LOS " + ((Object)component).name);
					}
				}
				else
				{
					Plugin.LogDebug("Skipped LOS " + ((Object)component).name);
				}
				result = val4;
				num = sqrMagnitude;
			}
			return result;
		}

		public PlayerControllerB? LookingForPlayerToHeal(bool ignoreLOS = false, bool shipOnly = false)
		{
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Invalid comparison between Unknown and I4
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			//IL_0125: Unknown result type (might be due to invalid IL or missing references)
			//IL_012a: Unknown result type (might be due to invalid IL or missing references)
			//IL_012e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0133: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0141: Unknown result type (might be due to invalid IL or missing references)
			//IL_0146: Unknown result type (might be due to invalid IL or missing references)
			//IL_016c: Unknown result type (might be due to invalid IL or missing references)
			PlayerControllerB npc = NpcController.Npc;
			float value = HealInfectionLevel.Value;
			if (HealPlayerState.CanHealPlayer(this, npc, value))
			{
				return npc;
			}
			float num = 30f;
			float num2 = 5f;
			float num3 = 90f;
			if (base.isOutside && !base.enemyType.canSeeThroughFog && (int)TimeOfDay.Instance.currentLevelWeather == 3)
			{
				num = Mathf.Clamp(num, 0f, 30f);
			}
			StartOfRound instance = StartOfRound.Instance;
			Transform transform = ((Component)NpcController.Npc.gameplayCamera).transform;
			float num4 = float.MaxValue;
			PlayerControllerB result = null;
			for (int i = 0; i < instance.allPlayerScripts.Length; i++)
			{
				PlayerControllerB val = instance.allPlayerScripts[i];
				if (!HealPlayerState.CanHealPlayer(this, val, value) || (shipOnly && !val.isInElevator && !val.isInHangarShipRoom))
				{
					continue;
				}
				Vector3 position = ((Component)val.gameplayCamera).transform.position;
				Vector3 val2 = position - ((Component)this).transform.position;
				if (!(((Vector3)(ref val2)).sqrMagnitude > num * num) && (ignoreLOS || !Physics.Linecast(transform.position, position, instance.collidersAndRoomMaskAndDefault)))
				{
					Vector3 val3 = position - transform.position;
					float num5 = Vector3.Distance(transform.position, position);
					if ((ignoreLOS || Vector3.Angle(transform.forward, val3) < num3 || (num2 != -1f && num5 < num2)) && num5 < num4 && IsValidPathToTarget(((Component)val).transform.position))
					{
						num4 = num5;
						result = val;
					}
				}
			}
			return result;
		}

		public bool IsGrabbableObjectGrabbable(GrabbableObject grabbableObject, EnumGrabbableObjectCall enumGrabbable = EnumGrabbableObjectCall.Default)
		{
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Invalid comparison between Unknown and I4
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Invalid comparison between Unknown and I4
			//IL_01fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0268: Unknown result type (might be due to invalid IL or missing references)
			//IL_0274: Unknown result type (might be due to invalid IL or missing references)
			//IL_0279: Unknown result type (might be due to invalid IL or missing references)
			//IL_027e: Unknown result type (might be due to invalid IL or missing references)
			if (enumGrabbable == EnumGrabbableObjectCall.Selling)
			{
				Plugin.LogWarning("IsGrabbableObjectGrabbable was called with enumGrabbable set to Selling. You should use IsGrabbableObjectSellable instead!");
				return IsGrabbableObjectSellable(grabbableObject);
			}
			if ((Object)(object)grabbableObject == (Object)null || !((Component)grabbableObject).gameObject.activeSelf || (Object)(object)((NetworkBehaviour)grabbableObject).NetworkObject == (Object)null || !((NetworkBehaviour)grabbableObject).NetworkObject.IsSpawned)
			{
				return false;
			}
			bool flag = false;
			if (grabbableObject.isHeld)
			{
				flag = true;
				if (enumGrabbable != EnumGrabbableObjectCall.Reviving || !HasGrabbableObjectInInventory(grabbableObject, out var _))
				{
					return false;
				}
			}
			if (!grabbableObject.grabbable || grabbableObject.deactivated)
			{
				return false;
			}
			foreach (HoarderBugItem hoarderBugItem in HoarderBugAI.HoarderBugItems)
			{
				if (hoarderBugItem != null && grabbableObject.isInFactory && (Object)(object)hoarderBugItem.itemGrabbableObject == (Object)(object)grabbableObject && (int)hoarderBugItem.status != -1 && (int)hoarderBugItem.status != 1)
				{
					return false;
				}
			}
			RagdollGrabbableObject val = (RagdollGrabbableObject)(object)((grabbableObject is RagdollGrabbableObject) ? grabbableObject : null);
			if ((Object)(object)val != (Object)null && (Object)(object)val?.ragdoll?.attachedTo != (Object)null)
			{
				Transform attachedTo = val.ragdoll.attachedTo;
				object obj;
				if (attachedTo == null)
				{
					obj = null;
				}
				else
				{
					Transform parent = attachedTo.parent;
					if (parent == null)
					{
						obj = null;
					}
					else
					{
						GameObject gameObject = ((Component)parent).gameObject;
						obj = ((gameObject != null) ? gameObject.GetComponent<SpikeRoofTrap>() : null);
					}
				}
				SpikeRoofTrap val2 = (SpikeRoofTrap)obj;
				if ((Object)(object)val2 != (Object)null)
				{
					return false;
				}
			}
			CaveDwellerPhysicsProp val3 = (CaveDwellerPhysicsProp)(object)((grabbableObject is CaveDwellerPhysicsProp) ? grabbableObject : null);
			if (!grabbableObject.isHeld && ((Object)(object)val3 == (Object)null || !val3.caveDwellerScript.babyCrying) && DictJustDroppedItems.TryGetValue(grabbableObject, out var value) && Time.realtimeSinceStartup - value < 10f)
			{
				return false;
			}
			if (!AreHandsFree() && enumGrabbable != EnumGrabbableObjectCall.Reviving && HeldItem.itemProperties.twoHanded && grabbableObject.itemProperties.twoHanded && ((Object)(object)val3 == (Object)null || !val3.caveDwellerScript.babyCrying))
			{
				return false;
			}
			bool flag2 = State?.ShouldReturnToShip() ?? false;
			bool flag3 = LethalBotManager.Instance.LootTransferPlayers.Contains(NetworkBehaviourReference.op_Implicit((NetworkBehaviour)(object)NpcController.Npc));
			if (((!Plugin.Config.GrabItemsNearEntrances.Value && !LethalBotManager.Instance.AreAllHumanPlayersDead()) || (LethalBotManager.Instance.LootTransferPlayers.Count > 0 && !flag2)) && !flag3 && enumGrabbable != EnumGrabbableObjectCall.Reviving)
			{
				EntranceTeleport[] entrancesTeleportArray = EntrancesTeleportArray;
				foreach (EntranceTeleport val4 in entrancesTeleportArray)
				{
					if (val4.isEntranceToBuilding)
					{
						Vector3 val5 = ((Component)grabbableObject).transform.position - val4.entrancePoint.position;
						if (((Vector3)(ref val5)).sqrMagnitude < 36f)
						{
							return false;
						}
					}
				}
			}
			TrimDictJustDroppedItems();
			Vector3 navMeshPosition = RoundManager.Instance.GetNavMeshPosition(((Component)grabbableObject).transform.position, default(NavMeshHit), NpcController.Npc.grabDistance, -1);
			if (((NetworkBehaviour)this).IsOwner && !flag && !IsValidPathToTarget(navMeshPosition, calculatePathDistance: false, 2.7f, NpcController.Npc.grabDistance))
			{
				return false;
			}
			return true;
		}

		public bool IsGrabbableObjectSellable(GrabbableObject grabbableObject, bool ignoreHeldFlag = false, bool skipPathCheck = false)
		{
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			//IL_0117: Unknown result type (might be due to invalid IL or missing references)
			//IL_011d: Unknown result type (might be due to invalid IL or missing references)
			//IL_012f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0134: Unknown result type (might be due to invalid IL or missing references)
			//IL_0141: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)grabbableObject == (Object)null || !((Component)grabbableObject).gameObject.activeSelf || (Object)(object)((NetworkBehaviour)grabbableObject).NetworkObject == (Object)null || !((NetworkBehaviour)grabbableObject).NetworkObject.IsSpawned)
			{
				return false;
			}
			if ((!ignoreHeldFlag && grabbableObject.isHeld) || !grabbableObject.grabbable || grabbableObject.deactivated || !IsItemScrap(grabbableObject))
			{
				return false;
			}
			if (grabbableObject is GiftBoxItem || grabbableObject is ShotgunItem || grabbableObject is Shovel || grabbableObject is GunAmmo || grabbableObject is KnifeItem)
			{
				return false;
			}
			RagdollGrabbableObject val = (RagdollGrabbableObject)(object)((grabbableObject is RagdollGrabbableObject) ? grabbableObject : null);
			if ((Object)(object)val != (Object)null && ((Component)grabbableObject).tag == "PhysicsProp" && (Object)(object)((Component)grabbableObject).GetComponentInParent<DeadBodyInfo>() != (Object)null)
			{
				int valueOfAllScrapOnShip = LethalBotManager.GetValueOfAllScrapOnShip(this);
				if (valueOfAllScrapOnShip > 0)
				{
					return false;
				}
			}
			if (LethalBotManager.Instance.blacklistedItems.Contains(grabbableObject))
			{
				return false;
			}
			if (!ignoreHeldFlag && !AreHandsFree() && HeldItem.itemProperties.twoHanded && grabbableObject.itemProperties.twoHanded)
			{
				return false;
			}
			TrimDictJustDroppedItems();
			Vector3 navMeshPosition = RoundManager.Instance.GetNavMeshPosition(((Component)grabbableObject).transform.position, default(NavMeshHit), NpcController.Npc.grabDistance, -1);
			if (((NetworkBehaviour)this).IsOwner && !skipPathCheck && !IsValidPathToTarget(navMeshPosition, calculatePathDistance: false, 2.7f, NpcController.Npc.grabDistance))
			{
				return false;
			}
			return true;
		}

		private static void TrimDictJustDroppedItems()
		{
			if (DictJustDroppedItems == null || DictJustDroppedItems.Count <= 20)
			{
				return;
			}
			Plugin.LogDebug($"TrimDictJustDroppedItems Count{DictJustDroppedItems.Count}");
			List<GrabbableObject> list = (from x in DictJustDroppedItems
				where Time.realtimeSinceStartup - x.Value > 10f
				select x.Key).ToList();
			foreach (GrabbableObject item in list)
			{
				DictJustDroppedItems.Remove(item);
			}
		}

		public void SetLethalBotInElevator()
		{
			//IL_038f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0394: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_018a: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0252: Unknown result type (might be due to invalid IL or missing references)
			//IL_0262: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0321: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01db: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			//IL_011e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			StartOfRound instance = StartOfRound.Instance;
			if (NpcController == null)
			{
				return;
			}
			PlayerControllerB npc = NpcController.Npc;
			if (((NetworkBehaviour)this).IsOwner && npc.isPlayerControlled)
			{
				Vector3 position = ((Component)npc).transform.position;
				Bounds bounds = instance.shipBounds.bounds;
				Bounds bounds2 = instance.shipInnerRoomBounds.bounds;
				if (!instance.inShipPhase && instance.shipDoorsEnabled && !instance.suckingPlayersOutOfShip)
				{
					if (((Component)npc).transform.position.y < -600f)
					{
						npc.KillPlayer(Vector3.zero, false, (CauseOfDeath)2, 0, default(Vector3), false);
					}
					else if (NpcController.IsTouchingGround)
					{
						bool flag = ((Bounds)(ref bounds)).Contains(position + Vector3.up * 0.25f);
						if (npc.isInElevator != flag)
						{
							npc.isInElevator = flag;
							if (!flag)
							{
								npc.isInHangarShipRoom = false;
								base.isInsidePlayerShip = false;
							}
							npc.SetAllItemsInElevator(npc.isInHangarShipRoom, flag);
						}
						else
						{
							bool flag2 = ((Bounds)(ref bounds2)).Contains(position + Vector3.up * 0.25f);
							if (flag && npc.isInHangarShipRoom != flag2)
							{
								npc.isInHangarShipRoom = flag2;
								base.isInsidePlayerShip = flag2;
								npc.SetAllItemsInElevator(npc.isInHangarShipRoom, flag);
							}
						}
					}
				}
				else if (!instance.suckingPlayersOutOfShip)
				{
					if (choseRandomFlyDirForPlayer)
					{
						choseRandomFlyDirForPlayer = false;
						npc.TeleportPlayer(StartOfRoundPatch.GetPlayerSpawnPosition_ReversePatch(instance, (int)npc.playerClientId, simpleTeleport: false), false, 0f, false, true);
					}
					npc.isInElevator = true;
					npc.isInHangarShipRoom = true;
					base.isInsidePlayerShip = true;
					if (!base.isOutside)
					{
						((EnemyAI)this).SetEnemyOutside(true);
					}
					if ((Object)(object)instance.testRoom == (Object)null && !((Bounds)(ref bounds2)).Contains(position + Vector3.up * 0.25f))
					{
						npc.TeleportPlayer(StartOfRoundPatch.GetPlayerSpawnPosition_ReversePatch(instance, (int)npc.playerClientId, simpleTeleport: true), false, 0f, false, true);
					}
				}
				if ((Object)(object)npc.overridePhysicsParent != (Object)null)
				{
					if ((Object)(object)npc.overridePhysicsParent != (Object)(object)npc.lastSyncedPhysicsParent)
					{
						npc.parentedToElevatorLastFrame = false;
						npc.lastSyncedPhysicsParent = npc.overridePhysicsParent;
						ReParentLethalBot(npc.overridePhysicsParent);
						PlayerControllerBPatch.UpdatePlayerPhysicsParentServerRpc_ReversePatch(npc, npc.thisPlayerBody.localPosition, NetworkObjectReference.op_Implicit(((Component)npc.overridePhysicsParent).GetComponent<NetworkObject>()), isOverride: true, npc.isInElevator, npc.isInHangarShipRoom);
					}
				}
				else if ((Object)(object)npc.physicsParent != (Object)null)
				{
					if ((Object)(object)npc.physicsParent != (Object)(object)npc.lastSyncedPhysicsParent)
					{
						npc.parentedToElevatorLastFrame = false;
						npc.lastSyncedPhysicsParent = npc.physicsParent;
						ReParentLethalBot(npc.physicsParent);
						PlayerControllerBPatch.UpdatePlayerPhysicsParentServerRpc_ReversePatch(npc, npc.thisPlayerBody.localPosition, NetworkObjectReference.op_Implicit(((Component)npc.physicsParent).GetComponent<NetworkObject>()), isOverride: false, npc.isInElevator, npc.isInHangarShipRoom);
					}
				}
				else
				{
					if ((Object)(object)npc.lastSyncedPhysicsParent != (Object)null)
					{
						npc.lastSyncedPhysicsParent = null;
						ReParentLethalBot(npc.playersManager.playersContainer);
						PlayerControllerBPatch.RemovePlayerPhysicsParentServerRpc_ReversePatch(npc, npc.thisPlayerBody.localPosition, removeOverride: false, removeBoth: true, npc.isInElevator, npc.isInHangarShipRoom);
					}
					if (npc.isInElevator)
					{
						if (!npc.parentedToElevatorLastFrame)
						{
							npc.parentedToElevatorLastFrame = true;
							ReParentLethalBot(npc.playersManager.elevatorTransform);
						}
					}
					else if (npc.parentedToElevatorLastFrame)
					{
						npc.parentedToElevatorLastFrame = false;
						ReParentLethalBot(npc.playersManager.playersContainer);
					}
				}
			}
			npc.previousElevatorPosition = npc.playersManager.elevatorTransform.position;
		}

		public bool IsGrabbableObjectBlackListed(GrabbableObject grabbableObjectToEvaluate, EnumGrabbableObjectCall enumGrabbable = EnumGrabbableObjectCall.Default)
		{
			bool flag = State?.ShouldReturnToShip() ?? false;
			if (!Plugin.Config.GrabBeesNest.Value && enumGrabbable != EnumGrabbableObjectCall.Selling && ((Object)grabbableObjectToEvaluate).name.Contains("RedLocustHive"))
			{
				return true;
			}
			if (!Plugin.Config.GrabDeadBodies.Value && enumGrabbable != EnumGrabbableObjectCall.Selling && enumGrabbable != EnumGrabbableObjectCall.Reviving && ((Object)grabbableObjectToEvaluate).name.Contains("RagdollGrabbableObject") && ((Component)grabbableObjectToEvaluate).tag == "PhysicsProp" && (Object)(object)((Component)grabbableObjectToEvaluate).GetComponentInParent<DeadBodyInfo>() != (Object)null)
			{
				return true;
			}
			if (!Plugin.Config.GrabDockedApparatus.Value && enumGrabbable != EnumGrabbableObjectCall.Selling)
			{
				LungProp val = (LungProp)(object)((grabbableObjectToEvaluate is LungProp) ? grabbableObjectToEvaluate : null);
				if (val != null && val.isLungDocked)
				{
					return true;
				}
			}
			CaveDwellerPhysicsProp val2 = (CaveDwellerPhysicsProp)(object)((grabbableObjectToEvaluate is CaveDwellerPhysicsProp) ? grabbableObjectToEvaluate : null);
			if (val2 != null)
			{
				if (!Plugin.Config.TakeCareOfManeaterBaby.Value)
				{
					Plugin.LogDebug("Bot " + NpcController.Npc.playerUsername + " will not pickup the maneater, pickup is disabled!");
					return true;
				}
				CaveDwellerAI caveDwellerScript = val2.caveDwellerScript;
				if ((Object)(object)caveDwellerScript == (Object)null)
				{
					Plugin.LogDebug("Bot " + NpcController.Npc.playerUsername + " will not pickup the maneater, ai has not spawned!");
					return true;
				}
				if (!Plugin.Config.AdvancedManeaterBabyAI.Value)
				{
					Plugin.LogDebug("Bot " + NpcController.Npc.playerUsername + " will use basic AI for maneater!");
					if (!caveDwellerScript.babyCrying)
					{
						Plugin.LogDebug("Bot " + NpcController.Npc.playerUsername + " will not pickup the maneater, maneater is not crying!");
						return true;
					}
					return false;
				}
				BabyPlayerMemory babyMemoryOfPlayer_ReversePatch = CaveDwellerAIPatch.GetBabyMemoryOfPlayer_ReversePatch(caveDwellerScript, NpcController.Npc);
				if ((babyMemoryOfPlayer_ReversePatch == null || babyMemoryOfPlayer_ReversePatch.likeMeter < 0.1f) && !caveDwellerScript.babyCrying)
				{
					Plugin.LogDebug("Bot " + NpcController.Npc.playerUsername + " will not pickup the maneater, maneater is not crying and doesn't like us!");
					return true;
				}
			}
			if (enumGrabbable != EnumGrabbableObjectCall.Selling)
			{
				KiwiBabyItem val3 = (KiwiBabyItem)(object)((grabbableObjectToEvaluate is KiwiBabyItem) ? grabbableObjectToEvaluate : null);
				if (val3 != null)
				{
					GiantKiwiAI mamaAI = val3.mamaAI;
					if ((Object)(object)mamaAI == (Object)null || ((EnemyAI)mamaAI).isEnemyDead)
					{
						return false;
					}
					return true;
				}
			}
			if ((!Plugin.Config.GrabWheelbarrow.Value || enumGrabbable == EnumGrabbableObjectCall.Selling) && ((Object)grabbableObjectToEvaluate).name.Contains("Wheelbarrow"))
			{
				return true;
			}
			if ((!Plugin.Config.GrabShoppingCart.Value || enumGrabbable == EnumGrabbableObjectCall.Selling) && ((Object)grabbableObjectToEvaluate).name.Contains("ShoppingCart"))
			{
				return true;
			}
			if (enumGrabbable == EnumGrabbableObjectCall.Selling && ((Object)grabbableObjectToEvaluate).name.Contains("ZeddogPlushie"))
			{
				return true;
			}
			ExtensionLadderItem val4 = (ExtensionLadderItem)(object)((grabbableObjectToEvaluate is ExtensionLadderItem) ? grabbableObjectToEvaluate : null);
			if (val4 != null && (!flag || extensionLadderItemLadderActivated.Invoke(val4)))
			{
				return true;
			}
			LockPicker val5 = (LockPicker)(object)((grabbableObjectToEvaluate is LockPicker) ? grabbableObjectToEvaluate : null);
			if (val5 != null && val5.isPickingLock)
			{
				return true;
			}
			StunGrenadeItem val6 = (StunGrenadeItem)(object)((grabbableObjectToEvaluate is StunGrenadeItem) ? grabbableObjectToEvaluate : null);
			if (val6 != null && ((val6.pinPulled && !val6.explodeOnCollision) || val6.hasExploded))
			{
				return true;
			}
			return false;
		}

		internal static bool IsGrabbableObjectInContainerMod(GrabbableObject grabbableObject)
		{
			return ContainerBehaviour.CheckIfItemInContainer(grabbableObject);
		}

		internal static bool IsGrabbableObjectHeldByPikminMod(GrabbableObject grabbableObject)
		{
			PikminManager instance = PikminManager.instance;
			HashSet<PikminItem> hashSet = ((instance != null) ? instance.PikminItems : null);
			if (hashSet == null || hashSet.Count == 0)
			{
				return false;
			}
			foreach (PikminItem item in hashSet)
			{
				if ((Object)(object)item != (Object)null && (Object)(object)item.ItemScript == (Object)(object)grabbableObject && item.PikminOnItem.Count > 0)
				{
					return true;
				}
			}
			return false;
		}

		private void InitImportantColliders()
		{
			if (dictColliderToBridge == null)
			{
				dictColliderToBridge = new Dictionary<Collider, BridgeTrigger>();
			}
			else
			{
				dictColliderToBridge.Clear();
			}
			BridgeTrigger[] array = Object.FindObjectsOfType<BridgeTrigger>(false);
			BridgeTrigger[] array2 = array;
			foreach (BridgeTrigger val in array2)
			{
				Collider[] componentsInChildren = ((Component)val.bridgeAnimator).gameObject.GetComponentsInChildren<Collider>();
				Collider[] array3 = componentsInChildren;
				foreach (Collider key in array3)
				{
					if (!dictColliderToBridge.ContainsKey(key))
					{
						dictColliderToBridge.Add(key, val);
					}
				}
			}
		}

		public void HideShowModelReplacement(bool show)
		{
			BodyReplacementBase component = ((Component)NpcController.Npc).gameObject.GetComponent<BodyReplacementBase>();
			if (component != null)
			{
				component.SetAvatarRenderers(show);
			}
		}

		public void HideShowReplacementModelOnlyBody(bool show)
		{
			((Renderer)NpcController.Npc.thisPlayerModel).enabled = show;
			((Renderer)NpcController.Npc.thisPlayerModelLOD1).enabled = show;
			((Renderer)NpcController.Npc.thisPlayerModelLOD2).enabled = show;
			int layer = ((!show) ? 31 : 0);
			((Component)NpcController.Npc.thisPlayerModel).gameObject.layer = layer;
			((Component)NpcController.Npc.thisPlayerModelLOD1).gameObject.layer = layer;
			((Component)NpcController.Npc.thisPlayerModelLOD2).gameObject.layer = layer;
			((Component)NpcController.Npc.thisPlayerModelArms).gameObject.layer = layer;
			BodyReplacementBase component = ((Component)NpcController.Npc).gameObject.GetComponent<BodyReplacementBase>();
			if ((Object)(object)component == (Object)null)
			{
				HideShowLevelStickerBetaBadge(show);
				return;
			}
			GameObject replacementModel = component.replacementModel;
			if (!((Object)(object)replacementModel == (Object)null))
			{
				Renderer[] componentsInChildren = replacementModel.GetComponentsInChildren<Renderer>();
				foreach (Renderer val in componentsInChildren)
				{
					val.enabled = show;
				}
			}
		}

		public void HideShowLevelStickerBetaBadge(bool show)
		{
			((Renderer)NpcController.Npc.playerBetaBadgeMesh).enabled = show;
			((Renderer)((Component)NpcController.Npc.playerBadgeMesh).gameObject.GetComponent<MeshRenderer>()).enabled = show;
		}

		public void UpdateLethalBotVoiceEffects()
		{
			PlayerControllerB npc = NpcController.Npc;
			int num = (int)npc.playerClientId;
			PlayerControllerB val = ((!GameNetworkManager.Instance.localPlayerController.isPlayerDead || !((Object)(object)GameNetworkManager.Instance.localPlayerController.spectatedPlayerScript != (Object)null)) ? GameNetworkManager.Instance.localPlayerController : GameNetworkManager.Instance.localPlayerController.spectatedPlayerScript);
			bool flag = npc.speakingToWalkieTalkie && val.holdingWalkieTalkie && (Object)(object)npc != (Object)(object)val;
			if (npc.isPlayerDead)
			{
				((Behaviour)NpcController.AudioLowPassFilterComponent).enabled = false;
				((Behaviour)NpcController.AudioHighPassFilterComponent).enabled = false;
				base.creatureVoice.panStereo = 0f;
				SoundManager.Instance.playerVoicePitchTargets[num] = LethalBotIdentity.Voice.VoicePitch;
				SoundManager.Instance.SetPlayerPitch(LethalBotIdentity.Voice.VoicePitch, num);
				if (GameNetworkManager.Instance.localPlayerController.isPlayerDead)
				{
					base.creatureVoice.spatialBlend = 0f;
					base.creatureVoice.volume = LethalBotIdentity.Voice.Volume;
				}
				else
				{
					base.creatureVoice.spatialBlend = 1f;
					base.creatureVoice.volume = 0f;
				}
				return;
			}
			AudioLowPassFilter audioLowPassFilterComponent = NpcController.AudioLowPassFilterComponent;
			OccludeAudio occludeAudioComponent = NpcController.OccludeAudioComponent;
			((Behaviour)audioLowPassFilterComponent).enabled = true;
			occludeAudioComponent.overridingLowPass = flag || npc.voiceMuffledByEnemy;
			((Behaviour)NpcController.AudioHighPassFilterComponent).enabled = flag;
			if (!flag)
			{
				base.creatureVoice.spatialBlend = 1f;
				base.creatureVoice.bypassListenerEffects = false;
				base.creatureVoice.bypassEffects = false;
				base.creatureVoice.outputAudioMixerGroup = SoundManager.Instance.playerVoiceMixers[num];
				audioLowPassFilterComponent.lowpassResonanceQ = 1f;
			}
			else
			{
				base.creatureVoice.spatialBlend = 0f;
				if (GameNetworkManager.Instance.localPlayerController.isPlayerDead)
				{
					base.creatureVoice.panStereo = 0f;
					base.creatureVoice.outputAudioMixerGroup = SoundManager.Instance.playerVoiceMixers[num];
					base.creatureVoice.bypassListenerEffects = false;
					base.creatureVoice.bypassEffects = false;
				}
				else
				{
					base.creatureVoice.panStereo = 0.4f;
					base.creatureVoice.bypassListenerEffects = false;
					base.creatureVoice.bypassEffects = false;
					base.creatureVoice.outputAudioMixerGroup = SoundManager.Instance.playerVoiceMixers[num];
				}
				occludeAudioComponent.lowPassOverride = 4000f;
				audioLowPassFilterComponent.lowpassResonanceQ = 3f;
			}
			if (GameNetworkManager.Instance.localPlayerController.isPlayerDead)
			{
				base.creatureVoice.volume = LethalBotIdentity.Voice.Volume * 0.8f;
			}
			else
			{
				base.creatureVoice.volume = LethalBotIdentity.Voice.Volume;
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void PlayAudioServerRpc(string smallPathAudioClip, int enumTalkativeness)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: 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_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				ServerRpcParams val = default(ServerRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(2347806360u, val, (RpcDelivery)0);
				bool flag = smallPathAudioClip != null;
				((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				if (flag)
				{
					((FastBufferWriter)(ref val2)).WriteValueSafe(smallPathAudioClip, false);
				}
				BytePacker.WriteValueBitPacked(val2, enumTalkativeness);
				((NetworkBehaviour)this).__endSendServerRpc(ref val2, 2347806360u, val, (RpcDelivery)0);
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
				PlayAudioClientRpc(smallPathAudioClip, enumTalkativeness);
			}
		}

		[ClientRpc]
		private void PlayAudioClientRpc(string smallPathAudioClip, int enumTalkativeness)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: 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_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val = default(ClientRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(3845412175u, val, (RpcDelivery)0);
				bool flag = smallPathAudioClip != null;
				((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				if (flag)
				{
					((FastBufferWriter)(ref val2)).WriteValueSafe(smallPathAudioClip, false);
				}
				BytePacker.WriteValueBitPacked(val2, enumTalkativeness);
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 3845412175u, val, (RpcDelivery)0);
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
				if (enumTalkativeness == Plugin.Config.Talkativeness.Value || LethalBotIdentity.Voice.CanPlayAudioAfterCooldown())
				{
					AudioManager.Instance.PlayAudio(smallPathAudioClip, LethalBotIdentity.Voice);
				}
			}
		}

		public void SyncTeleportLethalBot(Vector3 pos, bool? setOutside = null, EntranceTeleport? targetEntrance = null, bool withRotation = false, float rot = 0f, bool allowInteractTrigger = false, bool skipNavMeshCheck = false)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			if (!((NetworkBehaviour)this).IsOwner)
			{
				return;
			}
			TeleportLethalBot(pos, setOutside, targetEntrance, withRotation, rot, allowInteractTrigger, skipNavMeshCheck);
			if ((Object)(object)targetEntrance != (Object)null)
			{
				if ((Object)(object)((NetworkBehaviour)targetEntrance).NetworkObject == (Object)null || !((NetworkBehaviour)targetEntrance).NetworkObject.IsSpawned)
				{
					Plugin.LogWarning(NpcController.Npc.playerUsername + ": Tried to teleport using an unspawned object! Networking to other clients, but without entrance sounds!");
					TeleportLethalBotServerRpc(new TeleportLethalBotNetworkSerializable
					{
						Pos = pos,
						SetOutside = setOutside,
						WithRotation = withRotation,
						Rot = rot,
						AllowInteractTrigger = allowInteractTrigger,
						SkipNavMeshCheck = skipNavMeshCheck
					});
				}
				else
				{
					TeleportLethalBotServerRpc(new TeleportLethalBotNetworkSerializable
					{
						Pos = pos,
						SetOutside = setOutside,
						WithRotation = withRotation,
						Rot = rot,
						TargetEntrance = NetworkObjectReference.op_Implicit(((NetworkBehaviour)targetEntrance).NetworkObject),
						AllowInteractTrigger = allowInteractTrigger,
						SkipNavMeshCheck = skipNavMeshCheck
					});
				}
			}
			else
			{
				TeleportLethalBotServerRpc(new TeleportLethalBotNetworkSerializable
				{
					Pos = pos,
					SetOutside = setOutside,
					WithRotation = withRotation,
					Rot = rot,
					AllowInteractTrigger = allowInteractTrigger,
					SkipNavMeshCheck = skipNavMeshCheck
				});
			}
		}

		[ServerRpc]
		private void TeleportLethalBotServerRpc(TeleportLethalBotNetworkSerializable teleportData)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Invalid comparison between Unknown and I4
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Invalid comparison between Unknown and I4
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				if (((NetworkBehaviour)this).OwnerClientId != networkManager.LocalClientId)
				{
					if ((int)networkManager.LogLevel <= 1)
					{
						Debug.LogError((object)"Only the owner can invoke a ServerRpc that requires ownership!");
					}
					return;
				}
				ServerRpcParams val = default(ServerRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(3126638350u, val, (RpcDelivery)0);
				((FastBufferWriter)(ref val2)).WriteValueSafe<TeleportLethalBotNetworkSerializable>(ref teleportData, default(ForNetworkSerializable));
				((NetworkBehaviour)this).__endSendServerRpc(ref val2, 3126638350u, val, (RpcDelivery)0);
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
				TeleportLethalBotClientRpc(teleportData);
			}
		}

		[ClientRpc]
		private void TeleportLethalBotClientRpc(TeleportLethalBotNetworkSerializable teleportLethalBotNetworkSerializable)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0138: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val = default(ClientRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(1974751311u, val, (RpcDelivery)0);
				((FastBufferWriter)(ref val2)).WriteValueSafe<TeleportLethalBotNetworkSerializable>(ref teleportLethalBotNetworkSerializable, default(ForNetworkSerializable));
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 1974751311u, val, (RpcDelivery)0);
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 || (!networkManager.IsClient && !networkManager.IsHost))
			{
				return;
			}
			((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
			if (((NetworkBehaviour)this).IsOwner)
			{
				return;
			}
			NetworkObjectReference? targetEntrance = teleportLethalBotNetworkSerializable.TargetEntrance;
			EntranceTeleport val3 = null;
			if (targetEntrance.HasValue)
			{
				NetworkObjectReference value = targetEntrance.Value;
				NetworkObject val4 = default(NetworkObject);
				if (((NetworkObjectReference)(ref value)).TryGet(ref val4, (NetworkManager)null))
				{
					val3 = ((Component)val4).GetComponent<EntranceTeleport>();
					if ((Object)(object)val3 == (Object)null)
					{
						Plugin.LogWarning("Failed to retrieve EntranceTeleport for teleportation, sound effects will not play.");
					}
				}
				else
				{
					Plugin.LogWarning("Failed to retrieve EntranceTeleport for teleportation, sound effects will not play.");
				}
			}
			TeleportLethalBot(teleportLethalBotNetworkSerializable.Pos, teleportLethalBotNetworkSerializable.SetOutside, val3, teleportLethalBotNetworkSerializable.WithRotation, teleportLethalBotNetworkSerializable.Rot, teleportLethalBotNetworkSerializable.AllowInteractTrigger, teleportLethalBotNetworkSerializable.SkipNavMeshCheck);
		}

		public void TeleportLethalBot(Vector3 pos, bool? setOutside = null, EntranceTeleport? targetEntrance = null, bool withRotation = false, float rot = 0f, bool allowInteractTrigger = false, bool skipNavMeshCheck = false)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_016f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0184: Unknown result type (might be due to invalid IL or missing references)
			//IL_018f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0199: Unknown result type (might be due to invalid IL or missing references)
			TeleportAgentAIAndBody(pos, skipNavMeshCheck);
			PlayerControllerB npc = NpcController.Npc;
			if (!allowInteractTrigger && (Object)(object)npc.currentTriggerInAnimationWith != (Object)null)
			{
				npc.CancelSpecialTriggerAnimations();
				State?.LethalBotInteraction?.StopHoldInteractionOnTrigger();
				if (useInteractTriggerCoroutine != null)
				{
					((MonoBehaviour)this).StopCoroutine(useInteractTriggerCoroutine);
					useInteractTriggerCoroutine = null;
				}
			}
			if (Object.op_Implicit((Object)(object)npc.inAnimationWithEnemy))
			{
				npc.inAnimationWithEnemy.CancelSpecialAnimationWithPlayer();
			}
			if (withRotation)
			{
				((Component)npc).transform.localEulerAngles = new Vector3(0f, rot, 0f);
			}
			if (!setOutside.HasValue)
			{
				setOutside = ((targetEntrance != null) ? (!targetEntrance.isEntranceToBuilding) : (pos.y >= -80f));
			}
			npc.isInsideFactory = !setOutside.Value;
			if (base.isOutside != setOutside.Value)
			{
				((EnemyAI)this).SetEnemyOutside(setOutside.Value);
			}
			Plugin.LogDebug($"Teleport lethalBot {npc.playerUsername} to {pos} outside {setOutside.Value}");
			if ((Object)(object)targetEntrance != (Object)null)
			{
				Plugin.LogDebug($"Entrance type: {targetEntrance.isEntranceToBuilding}");
			}
			Plugin.LogDebug($"Is lethalBot in the facility: {npc.isInsideFactory}");
			if (!((Object)(object)targetEntrance != (Object)null))
			{
				return;
			}
			Transform thisPlayerBody = npc.thisPlayerBody;
			thisPlayerBody.eulerAngles = new Vector3(thisPlayerBody.eulerAngles.x, targetEntrance.exitScript.entrancePoint.eulerAngles.y, thisPlayerBody.eulerAngles.z);
			TimeSinceTeleporting = Time.timeSinceLevelLoad;
			targetEntrance.timeAtLastUse = Time.realtimeSinceStartup;
			targetEntrance.FinishOpeningEntrance(false);
			AudioReverbPresets val = Object.FindObjectOfType<AudioReverbPresets>();
			if (targetEntrance.audioReverbPreset != -1)
			{
				val.audioPresets[targetEntrance.audioReverbPreset].ChangeAudioReverbForPlayer(npc);
				if ((Object)(object)targetEntrance.entrancePointAudio != (Object)null)
				{
					targetEntrance.PlayAudioAtTeleportPositions();
				}
			}
			if (AIState.IsFrontEntrance(targetEntrance) && targetEntrance.isEntranceToBuilding)
			{
				DunGenTileTracker dunGenTileTracker = DunGenTileTracker;
				if ((Object)(object)dunGenTileTracker != (Object)null)
				{
					dunGenTileTracker.SetToStartTile();
				}
			}
		}

		private void TeleportAgentAIAndBody(Vector3 pos, bool skipNavMeshCheck = false)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: 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_0018: 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_0022: 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_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = (base.serverPosition = (skipNavMeshCheck ? pos : RoundManager.Instance.GetNavMeshPosition(pos, default(NavMeshHit), 2.7f, -1)));
			((Component)NpcController.Npc).transform.position = val;
			((Component)this).transform.position = val;
			NavMeshAgent agent = base.agent;
			if (agent != null)
			{
				agent.Warp(val);
			}
			if (!AreHandsFree())
			{
				HeldItem.EnableItemMeshes(true);
			}
		}

		public void SyncTeleportLethalBotVehicle(Vector3 pos, bool enteringVehicle, NetworkBehaviourReference networkBehaviourReferenceVehicle)
		{
			//IL_000a: 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_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			if (((NetworkBehaviour)this).IsOwner)
			{
				TeleportLethalBotVehicle(pos, enteringVehicle, networkBehaviourReferenceVehicle);
				TeleportLethalBotVehicleServerRpc(pos, enteringVehicle, networkBehaviourReferenceVehicle);
			}
		}

		[ServerRpc]
		private void TeleportLethalBotVehicleServerRpc(Vector3 pos, bool enteringVehicle, NetworkBehaviourReference networkBehaviourReferenceVehicle)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: Invalid comparison between Unknown and I4
			//IL_014a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0150: Unknown result type (might be due to invalid IL or missing references)
			//IL_0152: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Invalid comparison between Unknown and I4
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				if (((NetworkBehaviour)this).OwnerClientId != networkManager.LocalClientId)
				{
					if ((int)networkManager.LogLevel <= 1)
					{
						Debug.LogError((object)"Only the owner can invoke a ServerRpc that requires ownership!");
					}
					return;
				}
				ServerRpcParams val = default(ServerRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(80187027u, val, (RpcDelivery)0);
				((FastBufferWriter)(ref val2)).WriteValueSafe(ref pos);
				((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref enteringVehicle, default(ForPrimitives));
				((FastBufferWriter)(ref val2)).WriteValueSafe<NetworkBehaviourReference>(ref networkBehaviourReferenceVehicle, default(ForNetworkSerializable));
				((NetworkBehaviour)this).__endSendServerRpc(ref val2, 80187027u, val, (RpcDelivery)0);
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
				TeleportLethalBotVehicleClientRpc(pos, enteringVehicle, networkBehaviourReferenceVehicle);
			}
		}

		[ClientRpc]
		private void TeleportLethalBotVehicleClientRpc(Vector3 pos, bool enteringVehicle, NetworkBehaviourReference networkBehaviourReferenceVehicle)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: Unknown result type (might be due to invalid IL or missing references)
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val = default(ClientRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(2828257530u, val, (RpcDelivery)0);
				((FastBufferWriter)(ref val2)).WriteValueSafe(ref pos);
				((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref enteringVehicle, default(ForPrimitives));
				((FastBufferWriter)(ref val2)).WriteValueSafe<NetworkBehaviourReference>(ref networkBehaviourReferenceVehicle, default(ForNetworkSerializable));
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 2828257530u, val, (RpcDelivery)0);
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
				if (!((NetworkBehaviour)this).IsOwner)
				{
					TeleportLethalBotVehicle(pos, enteringVehicle, networkBehaviourReferenceVehicle);
				}
			}
		}

		private void TeleportLethalBotVehicle(Vector3 pos, bool enteringVehicle, NetworkBehaviourReference networkBehaviourReferenceVehicle)
		{
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			if (enteringVehicle)
			{
				if ((Object)(object)base.agent != (Object)null)
				{
					SetAgent(enabled: false);
				}
				((Component)NpcController.Npc).transform.position = pos;
				StateControllerMovement = EnumStateControllerMovement.Fixed;
			}
			else
			{
				TeleportLethalBot(pos);
				StateControllerMovement = EnumStateControllerMovement.FollowAgent;
			}
			NpcController.IsControllerInCruiser = enteringVehicle;
			if (NpcController.IsControllerInCruiser)
			{
				VehicleController val = default(VehicleController);
				if (((NetworkBehaviourReference)(ref networkBehaviourReferenceVehicle)).TryGet<VehicleController>(ref val, (NetworkManager)null))
				{
					Plugin.LogDebug(NpcController.Npc.playerUsername + " enters vehicle");
					NpcController.Npc.physicsParent = ((Component)val).transform;
					ReParentLethalBot(((Component)val).transform);
				}
				StopSinkingState();
			}
			else
			{
				Plugin.LogDebug(NpcController.Npc.playerUsername + " exits vehicle");
				NpcController.Npc.physicsParent = null;
				ReParentLethalBot(NpcController.Npc.playersManager.playersContainer);
			}
		}

		public override void SetEnemyOutside(bool outside = false)
		{
			((EnemyAI)this).SetEnemyOutside(outside);
			if (!outside)
			{
				return;
			}
			Transform[] insideShipPositions = StartOfRound.Instance.insideShipPositions;
			if (insideShipPositions == null || insideShipPositions.Length == 0)
			{
				Plugin.LogWarning("No insideShipPositions found!");
				return;
			}
			List<GameObject> list = base.allAINodes.ToList();
			Transform[] array = insideShipPositions;
			foreach (Transform val in array)
			{
				if ((Object)(object)val != (Object)null)
				{
					list.Add(((Component)val).gameObject);
				}
				else
				{
					Plugin.LogWarning("Encountered null insideShipPosition node!");
				}
			}
			base.allAINodes = list.ToArray();
			if (outside && searchForScrap != null && (searchForScrap.searchInProgress || searchForScrap.visitInProgress))
			{
				searchForScrap.StopSearch();
			}
		}

		public void SyncAssignTargetAndSetMovingTo(PlayerControllerB newTarget)
		{
			LethalBotAI lethalBotAI = LethalBotManager.Instance.GetLethalBotAI(newTarget);
			ulong num = (((Object)(object)lethalBotAI != (Object)null) ? ((NetworkBehaviour)lethalBotAI).OwnerClientId : newTarget.actualClientId);
			if (((NetworkBehaviour)this).OwnerClientId != num)
			{
				((EnemyAI)this).ChangeOwnershipOfEnemy(num);
				if (((NetworkBehaviour)this).IsServer)
				{
					SyncFromAssignTargetAndSetMovingToClientRpc(newTarget.playerClientId);
				}
				else
				{
					SyncAssignTargetAndSetMovingToServerRpc(newTarget.playerClientId);
				}
			}
			else
			{
				AssignTargetAndSetMovingTo(newTarget.playerClientId);
			}
		}

		[ServerRpc(RequireOwnership = false)]
		private void SyncAssignTargetAndSetMovingToServerRpc(ulong playerid)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val = default(ServerRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(1452686656u, val, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val2, playerid);
					((NetworkBehaviour)this).__endSendServerRpc(ref val2, 1452686656u, val, (RpcDelivery)0);
				}
				if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
					SyncFromAssignTargetAndSetMovingToClientRpc(playerid);
				}
			}
		}

		[ClientRpc]
		private void SyncFromAssignTargetAndSetMovingToClientRpc(ulong playerid)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val = default(ClientRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(1231162204u, val, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val2, playerid);
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 1231162204u, val, (RpcDelivery)0);
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
				if (((NetworkBehaviour)this).IsOwner)
				{
					AssignTargetAndSetMovingTo(playerid);
				}
			}
		}

		private void AssignTargetAndSetMovingTo(ulong playerid)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			PlayerControllerB val = StartOfRound.Instance.allPlayerScripts[playerid];
			((EnemyAI)this).SetMovingTowardsTargetPlayer(val);
			SetDestinationToPositionLethalBotAI(((Component)base.targetPlayer).transform.position);
			if (NpcController.IsControllerInCruiser)
			{
				State = new PlayerInCruiserState(this, GetVehicleCruiserTargetPlayerIsIn());
			}
			else if (State == null || State.GetAIState() != EnumAIStates.GetCloseToPlayer || (Object)(object)base.targetPlayer != (Object)(object)val)
			{
				State = new GetCloseToPlayerState(this, val);
			}
		}

		public void SyncUpdateLethalBotPosition(Vector3 newPos, bool inElevator, bool inShipRoom, bool exhausted, bool isPlayerGrounded)
		{
			//IL_0017: 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)
			if (((NetworkBehaviour)this).IsServer)
			{
				UpdateLethalBotPositionClientRpc(newPos, inElevator, inShipRoom, exhausted, isPlayerGrounded);
			}
			else
			{
				UpdateLethalBotPositionServerRpc(newPos, inElevator, inShipRoom, exhausted, isPlayerGrounded);
			}
		}

		[ServerRpc(RequireOwnership = false)]
		private void UpdateLethalBotPositionServerRpc(Vector3 newPos, bool inElevator, bool inShipRoom, bool exhausted, bool isPlayerGrounded)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_013a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0140: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val = default(ServerRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(3832073478u, val, (RpcDelivery)0);
					((FastBufferWriter)(ref val2)).WriteValueSafe(ref newPos);
					((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref inElevator, default(ForPrimitives));
					((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref inShipRoom, default(ForPrimitives));
					((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref exhausted, default(ForPrimitives));
					((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref isPlayerGrounded, default(ForPrimitives));
					((NetworkBehaviour)this).__endSendServerRpc(ref val2, 3832073478u, val, (RpcDelivery)0);
				}
				if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
					UpdateLethalBotPositionClientRpc(newPos, inElevator, inShipRoom, exhausted, isPlayerGrounded);
				}
			}
		}

		[ClientRpc]
		private void UpdateLethalBotPositionClientRpc(Vector3 newPos, bool inElevator, bool isInShip, bool exhausted, bool isPlayerGrounded)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_013a: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0277: Unknown result type (might be due to invalid IL or missing references)
			//IL_027c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0292: Unknown result type (might be due to invalid IL or missing references)
			//IL_0293: Unknown result type (might be due to invalid IL or missing references)
			//IL_0299: Unknown result type (might be due to invalid IL or missing references)
			//IL_029a: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0395: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a4: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val = default(ClientRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(188845853u, val, (RpcDelivery)0);
				((FastBufferWriter)(ref val2)).WriteValueSafe(ref newPos);
				((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref inElevator, default(ForPrimitives));
				((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref isInShip, default(ForPrimitives));
				((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref exhausted, default(ForPrimitives));
				((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref isPlayerGrounded, default(ForPrimitives));
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 188845853u, val, (RpcDelivery)0);
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 || (!networkManager.IsClient && !networkManager.IsHost))
			{
				return;
			}
			((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
			if (NpcController == null)
			{
				return;
			}
			PlayerControllerB npc = NpcController.Npc;
			PlayerStats obj = npc.playersManager.gameStats.allPlayerStats[npc.playerClientId];
			obj.stepsTaken++;
			EndOfGameStats gameStats = npc.playersManager.gameStats;
			gameStats.allStepsTaken++;
			bool flag = npc.currentFootstepSurfaceIndex == 8 && ((((NetworkBehaviour)this).IsOwner && NpcController.IsTouchingGround) || isPlayerGrounded);
			if (npc.bleedingHeavily || flag)
			{
				npc.DropBlood(Vector3.down, npc.bleedingHeavily, flag);
			}
			npc.timeSincePlayerMoving = 0f;
			if (((NetworkBehaviour)this).IsOwner)
			{
				return;
			}
			if (!inElevator)
			{
				npc.isInHangarShipRoom = false;
			}
			npc.isExhausted = exhausted;
			npc.isInElevator = inElevator;
			npc.isInHangarShipRoom = isInShip;
			base.isInsidePlayerShip = isInShip;
			GrabbableObject[] itemSlots = npc.ItemSlots;
			foreach (GrabbableObject val3 in itemSlots)
			{
				if ((Object)(object)val3 != (Object)null && val3.isHeld)
				{
					if (val3.isInShipRoom != isInShip)
					{
						npc.SetItemInElevator(isInShip, inElevator, val3);
					}
					val3.isInElevator = inElevator;
				}
			}
			GrabbableObject itemOnlySlot = npc.ItemOnlySlot;
			if ((Object)(object)itemOnlySlot != (Object)null)
			{
				npc.SetItemInElevator(isInShip, inElevator, itemOnlySlot);
			}
			npc.oldPlayerPosition = npc.serverPlayerPosition;
			if (!npc.disableSyncInAnimation && !npc.inVehicleAnimation)
			{
				npc.serverPlayerPosition = newPos;
				base.serverPosition = newPos;
				((Component)this).transform.position = newPos;
			}
			if ((Object)(object)npc.overridePhysicsParent != (Object)null)
			{
				if ((Object)(object)npc.overridePhysicsParent != (Object)(object)npc.lastSyncedPhysicsParent)
				{
					npc.lastSyncedPhysicsParent = npc.overridePhysicsParent;
					ReParentLethalBot(npc.overridePhysicsParent);
				}
			}
			else if ((Object)(object)npc.physicsParent != (Object)null)
			{
				if ((Object)(object)npc.physicsParent != (Object)(object)npc.lastSyncedPhysicsParent)
				{
					npc.lastSyncedPhysicsParent = npc.physicsParent;
					ReParentLethalBot(npc.physicsParent);
				}
			}
			else if ((Object)(object)npc.lastSyncedPhysicsParent != (Object)null)
			{
				npc.lastSyncedPhysicsParent = null;
			}
			else if (npc.isInElevator)
			{
				if (!npc.parentedToElevatorLastFrame)
				{
					npc.parentedToElevatorLastFrame = true;
					ReParentLethalBot(npc.playersManager.elevatorTransform);
				}
			}
			else if (npc.parentedToElevatorLastFrame)
			{
				npc.parentedToElevatorLastFrame = false;
				ReParentLethalBot(npc.playersManager.playersContainer);
				((Component)npc).transform.eulerAngles = new Vector3(0f, ((Component)npc).transform.eulerAngles.y, 0f);
			}
		}

		public void SyncUpdateLethalBotRotationAndLook(string stateIndicator, LookAtTarget lookAtTarget)
		{
			if (((NetworkBehaviour)this).IsServer)
			{
				UpdateLethalBotRotationAndLookClientRpc(stateIndicator, lookAtTarget);
			}
			else
			{
				UpdatelLethalBotRotationAndLookServerRpc(stateIndicator, lookAtTarget);
			}
		}

		[ServerRpc(RequireOwnership = false)]
		private void UpdatelLethalBotRotationAndLookServerRpc(string stateIndicator, LookAtTarget lookAtTarget)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: 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_014a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				ServerRpcParams val = default(ServerRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(1296515749u, val, (RpcDelivery)0);
				bool flag = stateIndicator != null;
				((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				if (flag)
				{
					((FastBufferWriter)(ref val2)).WriteValueSafe(stateIndicator, false);
				}
				bool flag2 = (object)lookAtTarget != null;
				((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref flag2, default(ForPrimitives));
				if (flag2)
				{
					((FastBufferWriter)(ref val2)).WriteValueSafe<LookAtTarget>(ref lookAtTarget, default(ForNetworkSerializable));
				}
				((NetworkBehaviour)this).__endSendServerRpc(ref val2, 1296515749u, val, (RpcDelivery)0);
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
				UpdateLethalBotRotationAndLookClientRpc(stateIndicator, lookAtTarget);
			}
		}

		[ClientRpc]
		private void UpdateLethalBotRotationAndLookClientRpc(string stateIndicator, LookAtTarget lookAtTarget)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: 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_014a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val = default(ClientRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(858392864u, val, (RpcDelivery)0);
				bool flag = stateIndicator != null;
				((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				if (flag)
				{
					((FastBufferWriter)(ref val2)).WriteValueSafe(stateIndicator, false);
				}
				bool flag2 = (object)lookAtTarget != null;
				((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref flag2, default(ForPrimitives));
				if (flag2)
				{
					((FastBufferWriter)(ref val2)).WriteValueSafe<LookAtTarget>(ref lookAtTarget, default(ForNetworkSerializable));
				}
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 858392864u, val, (RpcDelivery)0);
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 || (!networkManager.IsClient && !networkManager.IsHost))
			{
				return;
			}
			((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
			if (NpcController != null)
			{
				PlayerStats obj = NpcController.Npc.playersManager.gameStats.allPlayerStats[NpcController.Npc.playerClientId];
				obj.turnAmount++;
				if (!IsClientOwnerOfLethalBot())
				{
					stateIndicatorServer = stateIndicator;
					NpcController.SetCurrentLookAt(lookAtTarget);
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void UpdateLethalBotAnimationServerRpc(int animationState, float animationSpeed)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val = default(ServerRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(1568272076u, val, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val2, animationState);
					((FastBufferWriter)(ref val2)).WriteValueSafe<float>(ref animationSpeed, default(ForPrimitives));
					((NetworkBehaviour)this).__endSendServerRpc(ref val2, 1568272076u, val, (RpcDelivery)0);
				}
				if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
					UpdateLethalBotAnimationClientRpc(animationState, animationSpeed);
				}
			}
		}

		[ClientRpc]
		private void UpdateLethalBotAnimationClientRpc(int animationState, float animationSpeed)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val = default(ClientRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(3685310123u, val, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val2, animationState);
				((FastBufferWriter)(ref val2)).WriteValueSafe<float>(ref animationSpeed, default(ForPrimitives));
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 3685310123u, val, (RpcDelivery)0);
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
				if (NpcController != null && !IsClientOwnerOfLethalBot())
				{
					NpcController.ApplyUpdateLethalBotAnimationsNotOwner(animationState, animationSpeed);
				}
			}
		}

		public void UpdateLethalBotSpecialAnimationValue(bool specialAnimation, float timed, bool climbingLadder)
		{
			if (IsClientOwnerOfLethalBot())
			{
				UpdateLethalBotSpecialAnimationServerRpc(specialAnimation, timed, climbingLadder);
			}
		}

		[ServerRpc(RequireOwnership = false)]
		private void UpdateLethalBotSpecialAnimationServerRpc(bool specialAnimation, float timed, bool climbingLadder)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val = default(ServerRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(3490817090u, val, (RpcDelivery)0);
					((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref specialAnimation, default(ForPrimitives));
					((FastBufferWriter)(ref val2)).WriteValueSafe<float>(ref timed, default(ForPrimitives));
					((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref climbingLadder, default(ForPrimitives));
					((NetworkBehaviour)this).__endSendServerRpc(ref val2, 3490817090u, val, (RpcDelivery)0);
				}
				if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
					UpdateLethalBotSpecialAnimationClientRpc(specialAnimation, timed, climbingLadder);
				}
			}
		}

		[ClientRpc]
		private void UpdateLethalBotSpecialAnimationClientRpc(bool specialAnimation, float timed, bool climbingLadder)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val = default(ClientRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(1849617960u, val, (RpcDelivery)0);
					((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref specialAnimation, default(ForPrimitives));
					((FastBufferWriter)(ref val2)).WriteValueSafe<float>(ref timed, default(ForPrimitives));
					((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref climbingLadder, default(ForPrimitives));
					((NetworkBehaviour)this).__endSendClientRpc(ref val2, 1849617960u, val, (RpcDelivery)0);
				}
				if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
					UpdateLethalBotSpecialAnimation(specialAnimation, timed, climbingLadder);
				}
			}
		}

		private void UpdateLethalBotSpecialAnimation(bool specialAnimation, float timed, bool climbingLadder)
		{
			if (NpcController != null)
			{
				PlayerControllerBPatch.IsInSpecialAnimationClientRpc_ReversePatch(NpcController.Npc, specialAnimation, timed, climbingLadder);
				NpcController.Npc.ResetZAndXRotation();
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void SyncSetFaceUnderwaterServerRpc(bool isUnderwater)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val = default(ServerRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(526852516u, val, (RpcDelivery)0);
					((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref isUnderwater, default(ForPrimitives));
					((NetworkBehaviour)this).__endSendServerRpc(ref val2, 526852516u, val, (RpcDelivery)0);
				}
				if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
					SyncSetFaceUnderwaterClientRpc(isUnderwater);
				}
			}
		}

		[ClientRpc]
		private void SyncSetFaceUnderwaterClientRpc(bool isUnderwater)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val = default(ClientRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(1320910236u, val, (RpcDelivery)0);
					((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref isUnderwater, default(ForPrimitives));
					((NetworkBehaviour)this).__endSendClientRpc(ref val2, 1320910236u, val, (RpcDelivery)0);
				}
				if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
					NpcController.Npc.isUnderwater = isUnderwater;
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void GrabItemServerRpc(NetworkObjectReference networkObjectReference, bool itemGiven)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: 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_01e2: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				ServerRpcParams val = default(ServerRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(1649434889u, val, (RpcDelivery)0);
				((FastBufferWriter)(ref val2)).WriteValueSafe<NetworkObjectReference>(ref networkObjectReference, default(ForNetworkSerializable));
				((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref itemGiven, default(ForPrimitives));
				((NetworkBehaviour)this).__endSendServerRpc(ref val2, 1649434889u, val, (RpcDelivery)0);
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 || (!networkManager.IsServer && !networkManager.IsHost))
			{
				return;
			}
			((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
			NetworkObject val3 = default(NetworkObject);
			if (!((NetworkObjectReference)(ref networkObjectReference)).TryGet(ref val3, (NetworkManager)null))
			{
				Plugin.LogError($"{NpcController.Npc.playerUsername} GrabItem for LethalBotAI {BotId} {NpcController.Npc.playerUsername}: Unknown to get network object from network object reference (Grab item RPC)");
				return;
			}
			GrabbableObject component = ((Component)val3).GetComponent<GrabbableObject>();
			if ((Object)(object)component == (Object)null)
			{
				Plugin.LogError($"{NpcController.Npc.playerUsername} GrabItem for LethalBotAI {BotId} {NpcController.Npc.playerUsername}: Unknown to get GrabbableObject component from network object (Grab item RPC)");
				return;
			}
			if (!itemGiven && !IsGrabbableObjectGrabbable(component) && !IsGrabbableObjectSellable(component))
			{
				Plugin.LogDebug($"{NpcController.Npc.playerUsername} grabbableObject {component} not grabbable");
				return;
			}
			if (val3.OwnerClientId != ((NetworkBehaviour)this).OwnerClientId)
			{
				val3.ChangeOwnership(((NetworkBehaviour)this).OwnerClientId);
			}
			GrabItemClientRpc(networkObjectReference);
		}

		[ClientRpc]
		private void GrabItemClientRpc(NetworkObjectReference networkObjectReference)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val = default(ClientRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(2115356580u, val, (RpcDelivery)0);
				((FastBufferWriter)(ref val2)).WriteValueSafe<NetworkObjectReference>(ref networkObjectReference, default(ForNetworkSerializable));
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 2115356580u, val, (RpcDelivery)0);
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 || (!networkManager.IsClient && !networkManager.IsHost))
			{
				return;
			}
			((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
			NetworkObject val3 = default(NetworkObject);
			if (!((NetworkObjectReference)(ref networkObjectReference)).TryGet(ref val3, (NetworkManager)null))
			{
				Plugin.LogError($"{NpcController.Npc.playerUsername} GrabItem for LethalBotAI {BotId} {NpcController.Npc.playerUsername}: Unknown to get network object from network object reference (Grab item RPC)");
				return;
			}
			GrabbableObject component = ((Component)val3).GetComponent<GrabbableObject>();
			int objectSlot;
			if ((Object)(object)component == (Object)null)
			{
				Plugin.LogError($"{NpcController.Npc.playerUsername} GrabItem for LethalBotAI {BotId} {NpcController.Npc.playerUsername}: Unknown to get GrabbableObject component from network object (Grab item RPC)");
			}
			else if (HasGrabbableObjectInInventory(component, out objectSlot))
			{
				Plugin.LogError($"{NpcController.Npc.playerUsername} cannot grab already held item {component} on client #{((NetworkBehaviour)this).NetworkManager.LocalClientId}");
			}
			else
			{
				GrabItem(component);
			}
		}

		private void GrabItem(GrabbableObject grabbableObject)
		{
			PlayerControllerB npc = NpcController.Npc;
			Plugin.LogDebug($"{npc.playerUsername} try to grab item {grabbableObject} on client #{((NetworkBehaviour)this).NetworkManager.LocalClientId}");
			int num = FirstEmptyItemSlot(grabbableObject);
			if (num == -1)
			{
				Plugin.LogDebug($"{npc.playerUsername} failed to grab item on client #{((NetworkBehaviour)this).NetworkManager.LocalClientId}, no free slots!");
				return;
			}
			SwitchToItemSlot(num, grabbableObject);
			grabbableObject.EnablePhysics(false);
			grabbableObject.isHeld = true;
			grabbableObject.hasHitGround = false;
			grabbableObject.isInFactory = npc.isInsideFactory;
			npc.SetItemInElevator(npc.isInHangarShipRoom, npc.isInElevator, grabbableObject);
			npc.twoHanded = grabbableObject.itemProperties.twoHanded;
			npc.twoHandedAnimation = grabbableObject.itemProperties.twoHandedAnimation;
			grabbableObject.parentObject = npc.serverItemHolder;
			npc.isHoldingObject = true;
			if ((Object)(object)grabbableObject.itemProperties.grabSFX != (Object)null)
			{
				npc.itemAudio.PlayOneShot(grabbableObject.itemProperties.grabSFX, 1f);
			}
			npc.carryWeight = Mathf.Clamp(npc.carryWeight + (grabbableObject.itemProperties.weight - 1f), 1f, 10f);
			NpcController.GrabbedObjectValidated = true;
			if (((NetworkBehaviour)this).IsOwner)
			{
				grabbableObject.GrabItemOnClient();
			}
			npc.playerBodyAnimator.SetBool("GrabInvalidated", false);
			npc.playerBodyAnimator.SetBool("GrabValidated", false);
			npc.playerBodyAnimator.SetBool("cancelHolding", false);
			npc.playerBodyAnimator.ResetTrigger("Throw");
			npc.isGrabbingObjectAnimation = true;
			SetSpecialGrabAnimationBool(setBool: true, grabbableObject);
			if (grabObjectCoroutine != null)
			{
				((MonoBehaviour)this).StopCoroutine(grabObjectCoroutine);
			}
			grabObjectCoroutine = ((MonoBehaviour)this).StartCoroutine(GrabAnimationCoroutine());
			Plugin.LogDebug($"{npc.playerUsername} Grabbed item {grabbableObject} on client #{((NetworkBehaviour)this).NetworkManager.LocalClientId}");
		}

		public int FirstEmptyItemSlot(GrabbableObject? grabbableObject = null)
		{
			PlayerControllerB npc = NpcController.Npc;
			GrabbableObject[] itemSlots = npc.ItemSlots;
			int num = -1;
			if ((Object)(object)npc.ItemOnlySlot == (Object)null && (Object)(object)grabbableObject != (Object)null && !grabbableObject.itemProperties.isScrap && !grabbableObject.itemProperties.twoHanded && !grabbableObject.itemProperties.disallowUtilitySlot)
			{
				num = 50;
			}
			else if (npc.currentItemSlot != 50 && (Object)(object)itemSlots[npc.currentItemSlot] == (Object)null)
			{
				num = npc.currentItemSlot;
			}
			else
			{
				for (int i = 0; i < itemSlots.Length; i++)
				{
					if ((Object)(object)itemSlots[i] == (Object)null)
					{
						num = i;
						break;
					}
				}
			}
			if (Plugin.IsModReservedItemSlotCoreLoaded)
			{
				return GetFirstEmptyReservedItemSlot(num, grabbableObject);
			}
			return num;
		}

		private int GetFirstEmptyReservedItemSlot(int foundIndex, GrabbableObject? grabbableObject = null)
		{
			if (PlayerPatcher.reservedHotbarSize <= 0 || !HUDPatcher.hasReservedItemSlotsAndEnabled)
			{
				return foundIndex;
			}
			if ((Object)(object)grabbableObject == (Object)null || !ReservedPlayerData.allPlayerData.TryGetValue(NpcController.Npc, out var value))
			{
				return foundIndex;
			}
			string itemName = grabbableObject.itemProperties.itemName;
			ReservedItemData val = default(ReservedItemData);
			if (SessionManager.TryGetUnlockedItemData(grabbableObject, ref val))
			{
				itemName = val.itemName;
			}
			ReservedItemSlotData firstEmptySlotForReservedItem = value.GetFirstEmptySlotForReservedItem(itemName);
			if (firstEmptySlotForReservedItem != null)
			{
				return firstEmptySlotForReservedItem.GetIndexInInventory(NpcController.Npc);
			}
			if (value.IsReservedItemSlot(foundIndex))
			{
				foundIndex = -1;
				GrabbableObject[] itemSlots = NpcController.Npc.ItemSlots;
				for (int i = 0; i < itemSlots.Length; i++)
				{
					if (!value.IsReservedItemSlot(i) && (Object)(object)itemSlots[i] == (Object)null)
					{
						foundIndex = i;
						break;
					}
				}
			}
			return foundIndex;
		}

		public static int GetInventorySize(PlayerControllerB playerController, GrabbableObject[] cachedInventory = null)
		{
			if (cachedInventory == null)
			{
				cachedInventory = playerController.ItemSlots;
			}
			int num = cachedInventory.Length;
			if (Plugin.IsModReservedItemSlotCoreLoaded)
			{
				return GetReservedInventorySize(playerController, num);
			}
			return num;
		}

		private static int GetReservedInventorySize(PlayerControllerB playerController, int inventorySize)
		{
			if (ReservedPlayerData.allPlayerData.TryGetValue(playerController, out var value))
			{
				return Mathf.Min(value.reservedHotbarStartIndex, inventorySize);
			}
			return inventorySize;
		}

		public void SwitchItemSlotsAndSync(int slotNum)
		{
			if (((NetworkBehaviour)this).IsServer)
			{
				SwitchItemSlotsClientRpc(slotNum);
			}
			else
			{
				SwitchItemSlotsServerRpc(slotNum);
			}
		}

		[ServerRpc(RequireOwnership = false)]
		private void SwitchItemSlotsServerRpc(int slotNum)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val = default(ServerRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(505760048u, val, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val2, slotNum);
					((NetworkBehaviour)this).__endSendServerRpc(ref val2, 505760048u, val, (RpcDelivery)0);
				}
				if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
					SwitchItemSlotsClientRpc(slotNum);
				}
			}
		}

		[ClientRpc]
		private void SwitchItemSlotsClientRpc(int slotNum)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val = default(ClientRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(4160081252u, val, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val2, slotNum);
					((NetworkBehaviour)this).__endSendClientRpc(ref val2, 4160081252u, val, (RpcDelivery)0);
				}
				if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
					SwitchToItemSlot(slotNum);
				}
			}
		}

		public bool CanSwitchItemSlot()
		{
			PlayerControllerB npc = NpcController.Npc;
			if (npc.isGrabbingObjectAnimation || npc.inSpecialInteractAnimation || npc.isTypingChat || npc.twoHanded || npc.activatingItem || npc.jetpackControls || npc.disablingJetpackControls || (bool)NpcController.ThrowingObject || (float)NpcController.TimeSinceSwitchingSlots < 0.3f)
			{
				return false;
			}
			return true;
		}

		internal void SwitchToItemSlot(int slot, GrabbableObject? fillSlotWithItem = null)
		{
			if (!CanSwitchItemSlot() && (Object)(object)fillSlotWithItem == (Object)null)
			{
				return;
			}
			PlayerControllerB npc = NpcController.Npc;
			GrabbableObject[] itemSlots = npc.ItemSlots;
			npc.currentItemSlot = slot;
			if ((Object)(object)fillSlotWithItem != (Object)null)
			{
				if (slot == 50)
				{
					npc.ItemOnlySlot = fillSlotWithItem;
				}
				else
				{
					itemSlots[slot] = fillSlotWithItem;
				}
			}
			if (!AreHandsFree())
			{
				HeldItem.playerHeldBy = npc;
				SetSpecialGrabAnimationBool(setBool: false, HeldItem);
				HeldItem.PocketItem();
				if (slot == 50)
				{
					if ((Object)(object)npc.ItemOnlySlot != (Object)null && !string.IsNullOrEmpty(npc.ItemOnlySlot.itemProperties.pocketAnim))
					{
						npc.playerBodyAnimator.SetTrigger(npc.ItemOnlySlot.itemProperties.pocketAnim);
					}
				}
				else if ((Object)(object)itemSlots[slot] != (Object)null && !string.IsNullOrEmpty(itemSlots[slot].itemProperties.pocketAnim))
				{
					npc.playerBodyAnimator.SetTrigger(itemSlots[slot].itemProperties.pocketAnim);
				}
			}
			GrabbableObject val = ((slot == 50) ? npc.ItemOnlySlot : itemSlots[slot]);
			if ((Object)(object)val != (Object)null)
			{
				val.playerHeldBy = npc;
				val.EquipItem();
				SetSpecialGrabAnimationBool(setBool: true, val);
				if (!AreHandsFree())
				{
					if (val.itemProperties.twoHandedAnimation || HeldItem.itemProperties.twoHandedAnimation)
					{
						npc.playerBodyAnimator.ResetTrigger("SwitchHoldAnimationTwoHanded");
						npc.playerBodyAnimator.SetTrigger("SwitchHoldAnimationTwoHanded");
					}
					npc.playerBodyAnimator.ResetTrigger("SwitchHoldAnimation");
					npc.playerBodyAnimator.SetTrigger("SwitchHoldAnimation");
				}
				npc.twoHandedAnimation = val.itemProperties.twoHandedAnimation;
				npc.twoHanded = val.itemProperties.twoHanded;
				npc.playerBodyAnimator.SetBool("GrabValidated", true);
				npc.playerBodyAnimator.SetBool("cancelHolding", false);
				npc.isHoldingObject = true;
				npc.currentlyHeldObjectServer = val;
				HeldItem = val;
				if ((Object)(object)fillSlotWithItem == (Object)null)
				{
					((Component)HeldItem).gameObject.GetComponent<AudioSource>().PlayOneShot(HeldItem.itemProperties.grabSFX, 0.6f);
				}
			}
			else
			{
				HeldItem = null;
				npc.currentlyHeldObject = null;
				npc.currentlyHeldObjectServer = null;
				npc.isHoldingObject = false;
				npc.twoHanded = false;
				npc.playerBodyAnimator.SetBool("cancelHolding", true);
			}
			NpcController.TimeSinceSwitchingSlots.Value = 0f;
		}

		[IteratorStateMachine(typeof(<GrabAnimationCoroutine>d__238))]
		private IEnumerator GrabAnimationCoroutine()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <GrabAnimationCoroutine>d__238(0)
			{
				<>4__this = this
			};
		}

		private void SetSpecialGrabAnimationBool(bool setBool, GrabbableObject? item)
		{
			NpcController.Npc.playerBodyAnimator.SetBool("Grab", setBool);
			if ((Object)(object)item != (Object)null && !string.IsNullOrEmpty(item.itemProperties.grabAnim))
			{
				try
				{
					NpcController.SetAnimationBoolForItem(item.itemProperties.grabAnim, setBool);
					NpcController.Npc.playerBodyAnimator.SetBool(item.itemProperties.grabAnim, setBool);
				}
				catch (Exception)
				{
					Plugin.LogError("An item tried to set an animator bool which does not exist: " + item.itemProperties.grabAnim);
				}
			}
		}

		public void DropItem(bool placeObject = false, NetworkObject parentObjectTo = null, Vector3 placePosition = default(Vector3), bool matchRotationOfParent = true)
		{
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0365: Unknown result type (might be due to invalid IL or missing references)
			//IL_036b: Unknown result type (might be due to invalid IL or missing references)
			//IL_036d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0372: Unknown result type (might be due to invalid IL or missing references)
			//IL_0389: Unknown result type (might be due to invalid IL or missing references)
			//IL_038e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0392: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02db: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0401: Unknown result type (might be due to invalid IL or missing references)
			//IL_030b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0310: Unknown result type (might be due to invalid IL or missing references)
			//IL_0314: Unknown result type (might be due to invalid IL or missing references)
			//IL_0243: Unknown result type (might be due to invalid IL or missing references)
			//IL_0248: Unknown result type (might be due to invalid IL or missing references)
			//IL_0259: Unknown result type (might be due to invalid IL or missing references)
			//IL_025e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0265: Unknown result type (might be due to invalid IL or missing references)
			//IL_0266: 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_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0357: Unknown result type (might be due to invalid IL or missing references)
			//IL_0359: Unknown result type (might be due to invalid IL or missing references)
			//IL_035e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0332: Unknown result type (might be due to invalid IL or missing references)
			//IL_0334: Unknown result type (might be due to invalid IL or missing references)
			//IL_0339: Unknown result type (might be due to invalid IL or missing references)
			//IL_047e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0483: Unknown result type (might be due to invalid IL or missing references)
			//IL_048a: Unknown result type (might be due to invalid IL or missing references)
			//IL_048c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c3: Unknown result type (might be due to invalid IL or missing references)
			Plugin.LogDebug($"{NpcController.Npc.playerUsername} Try to drop item on client #{((NetworkBehaviour)this).NetworkManager.LocalClientId}");
			if (AreHandsFree())
			{
				Plugin.LogError($"{NpcController.Npc.playerUsername} Try to drop not held item on client #{((NetworkBehaviour)this).NetworkManager.LocalClientId}");
				return;
			}
			GrabbableObject heldItem = HeldItem;
			Vector3 val = default(Vector3);
			NetworkObject physicsRegionOfDroppedObject = heldItem.GetPhysicsRegionOfDroppedObject(NpcController.Npc, ref val, false);
			if (!placeObject && (Object)(object)physicsRegionOfDroppedObject != (Object)null)
			{
				placePosition = val;
				parentObjectTo = physicsRegionOfDroppedObject;
				placeObject = true;
				matchRotationOfParent = false;
			}
			if (placeObject)
			{
				if ((Object)(object)parentObjectTo == (Object)null)
				{
					NpcController.ThrowingObject.Value = true;
					placePosition = ((!NpcController.Npc.isInElevator) ? StartOfRound.Instance.propsContainer.InverseTransformPoint(placePosition) : StartOfRound.Instance.elevatorTransform.InverseTransformPoint(placePosition));
					int floorYRot = (int)((Component)this).transform.localEulerAngles.y;
					SetObjectAsNoLongerHeld(heldItem, NpcController.Npc.isInElevator, NpcController.Npc.isInHangarShipRoom, placePosition, floorYRot);
					if ((Object)(object)((NetworkBehaviour)heldItem).NetworkObject == (Object)null || !((NetworkBehaviour)heldItem).NetworkObject.IsSpawned)
					{
						Plugin.LogWarning(NpcController.Npc.playerUsername + ": Tried to drop an unspawned object! Not networking to other clients!");
						return;
					}
					SetObjectAsNoLongerHeldServerRpc(new DropItemNetworkSerializable
					{
						DroppedInElevator = NpcController.Npc.isInElevator,
						DroppedInShipRoom = NpcController.Npc.isInHangarShipRoom,
						FloorYRot = floorYRot,
						GrabbedObject = NetworkObjectReference.op_Implicit(((NetworkBehaviour)heldItem).NetworkObject),
						TargetFloorPosition = placePosition,
						SkipPlayer = ((NetworkBehaviour)this).NetworkManager.LocalClientId
					});
				}
				else
				{
					PlaceGrabbableObject(heldItem, ((Component)parentObjectTo).transform, placePosition, matchRotationOfParent);
					if ((Object)(object)((NetworkBehaviour)heldItem).NetworkObject == (Object)null || !((NetworkBehaviour)heldItem).NetworkObject.IsSpawned)
					{
						Plugin.LogWarning(NpcController.Npc.playerUsername + ": Tried to drop an unspawned object! Not networking to other clients!");
						return;
					}
					PlaceGrabbableObjectServerRpc(new PlaceItemNetworkSerializable
					{
						GrabbedObject = NetworkObjectReference.op_Implicit(((NetworkBehaviour)heldItem).NetworkObject),
						MatchRotationOfParent = matchRotationOfParent,
						ParentObject = NetworkObjectReference.op_Implicit(parentObjectTo),
						PlacePositionOffset = placePosition,
						SkipPlayer = ((NetworkBehaviour)this).NetworkManager.LocalClientId
					});
				}
				return;
			}
			NpcController.ThrowingObject.Value = true;
			bool droppedInElevator = NpcController.Npc.isInElevator;
			Bounds bounds;
			Vector3 targetFloorPosition;
			if (!NpcController.Npc.isInElevator)
			{
				Vector3 val2 = ((!heldItem.itemProperties.allowDroppingAheadOfPlayer) ? heldItem.GetItemFloorPosition(default(Vector3)) : DropItemAheadOfPlayer(heldItem, NpcController.Npc));
				bounds = NpcController.Npc.playersManager.shipBounds.bounds;
				if (!((Bounds)(ref bounds)).Contains(val2))
				{
					targetFloorPosition = NpcController.Npc.playersManager.propsContainer.InverseTransformPoint(val2);
				}
				else
				{
					droppedInElevator = true;
					targetFloorPosition = NpcController.Npc.playersManager.elevatorTransform.InverseTransformPoint(val2);
				}
			}
			else
			{
				Vector3 itemFloorPosition = heldItem.GetItemFloorPosition(default(Vector3));
				bounds = NpcController.Npc.playersManager.shipBounds.bounds;
				if (!((Bounds)(ref bounds)).Contains(itemFloorPosition))
				{
					droppedInElevator = false;
					targetFloorPosition = NpcController.Npc.playersManager.propsContainer.InverseTransformPoint(itemFloorPosition);
				}
				else
				{
					targetFloorPosition = NpcController.Npc.playersManager.elevatorTransform.InverseTransformPoint(itemFloorPosition);
				}
			}
			int floorYRot2 = (int)((Component)this).transform.localEulerAngles.y;
			SetObjectAsNoLongerHeld(heldItem, droppedInElevator, NpcController.Npc.isInHangarShipRoom, targetFloorPosition, floorYRot2);
			if ((Object)(object)((NetworkBehaviour)heldItem).NetworkObject == (Object)null || !((NetworkBehaviour)heldItem).NetworkObject.IsSpawned)
			{
				Plugin.LogWarning(NpcController.Npc.playerUsername + ": Tried to drop an unspawned object! Not networking to other clients!");
				return;
			}
			SetObjectAsNoLongerHeldServerRpc(new DropItemNetworkSerializable
			{
				DroppedInElevator = droppedInElevator,
				DroppedInShipRoom = NpcController.Npc.isInHangarShipRoom,
				FloorYRot = floorYRot2,
				GrabbedObject = NetworkObjectReference.op_Implicit(((NetworkBehaviour)heldItem).NetworkObject),
				TargetFloorPosition = targetFloorPosition,
				SkipPlayer = ((NetworkBehaviour)this).NetworkManager.LocalClientId
			});
		}

		public void DestroyItemInSlot(int itemSlot)
		{
			if ((Object)(object)NetworkManager.Singleton == (Object)null || NetworkManager.Singleton.ShutdownInProgress)
			{
				return;
			}
			PlayerControllerB npc = NpcController.Npc;
			Plugin.LogDebug($"Destroying item in slot {itemSlot}; {npc.currentItemSlot}; is helditem null: {AreHandsFree()}");
			if (!AreHandsFree())
			{
				Plugin.LogDebug("HeldItem: " + HeldItem.itemProperties.itemName);
			}
			GrabbableObject val = ((itemSlot == 50) ? npc.ItemOnlySlot : npc.ItemSlots[itemSlot]);
			if (npc.isHoldingObject)
			{
				if (npc.currentItemSlot == itemSlot)
				{
					npc.carryWeight = Mathf.Clamp(npc.carryWeight - (val.itemProperties.weight - 1f), 1f, 10f);
					npc.isHoldingObject = false;
					npc.twoHanded = false;
					npc.playerBodyAnimator.SetBool("cancelHolding", true);
					npc.playerBodyAnimator.SetTrigger("Throw");
					npc.activatingItem = false;
				}
				if (!AreHandsFree() && (Object)(object)HeldItem == (Object)(object)val)
				{
					SetSpecialGrabAnimationBool(setBool: false, HeldItem);
					if (((NetworkBehaviour)this).IsOwner)
					{
						HeldItem.DiscardItemOnClient();
					}
					HeldItem = null;
					npc.currentlyHeldObjectServer = null;
				}
			}
			if (itemSlot == 50)
			{
				npc.ItemOnlySlot = null;
			}
			else
			{
				npc.ItemSlots[itemSlot] = null;
			}
			if (((NetworkBehaviour)this).IsServer && val != null)
			{
				((NetworkBehaviour)val).NetworkObject.Despawn(true);
			}
		}

		public void DropAllHeldItems(bool itemsFall = true, bool setInShip = false, bool setInElevator = false, Vector3 syncedPlayerPosition = default(Vector3), Vector3 syncedHeldObjectPosition = default(Vector3), Vector3 syncedHeldObjectRotation = default(Vector3), Vector3 syncedPlayerCamPosition = default(Vector3), Vector3 syncedPlayerCamRotation = default(Vector3))
		{
			//IL_0028: 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_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			PlayerControllerB npc = NpcController.Npc;
			GrabbableObject[] itemSlots = npc.ItemSlots;
			for (int i = 0; i < itemSlots.Length; i++)
			{
				GrabbableObject val = itemSlots[i];
				if (!((Object)(object)val == (Object)null))
				{
					PlayerControllerBPatch.DropHeldItem_ReversePatch(npc, val, itemsFall, disconnecting: false, syncedPlayerPosition, syncedHeldObjectPosition, syncedHeldObjectRotation, syncedPlayerCamPosition, syncedPlayerCamRotation, setInShip, setInElevator);
					DictJustDroppedItems[val] = Time.realtimeSinceStartup;
					if (((NetworkBehaviour)this).IsOwner)
					{
						npc.activatingItem = false;
					}
					itemSlots[i] = null;
				}
			}
			if (Object.op_Implicit((Object)(object)npc.ItemOnlySlot))
			{
				PlayerControllerBPatch.DropHeldItem_ReversePatch(npc, npc.ItemOnlySlot, itemsFall, disconnecting: false, syncedPlayerPosition, syncedHeldObjectPosition, syncedHeldObjectRotation, syncedPlayerCamPosition, syncedPlayerCamRotation, setInShip, setInElevator);
				DictJustDroppedItems[npc.ItemOnlySlot] = Time.realtimeSinceStartup;
				if (((NetworkBehaviour)this).IsOwner)
				{
					npc.activatingItem = false;
				}
				npc.ItemOnlySlot = null;
			}
			if (npc.isHoldingObject)
			{
				npc.isHoldingObject = false;
				if (!AreHandsFree())
				{
					SetSpecialGrabAnimationBool(setBool: false, HeldItem);
				}
				npc.playerBodyAnimator.SetBool("cancelHolding", true);
				npc.playerBodyAnimator.SetTrigger("Throw");
			}
			HeldItem = null;
			npc.activatingItem = false;
			npc.twoHanded = false;
			npc.carryWeight = 1f;
			npc.currentlyHeldObjectServer = null;
		}

		public void DespawnHeldObject()
		{
			GrabbableObject heldItem = HeldItem;
			PlayerControllerB npc = NpcController.Npc;
			Plugin.LogDebug(npc.playerUsername + " Try to despawn held item");
			if ((Object)(object)heldItem == (Object)null)
			{
				Plugin.LogError(npc.playerUsername + " Try to despawn, but bot is holding nothing");
				return;
			}
			Plugin.LogDebug($"{npc.playerUsername} Try to despawn held item {HeldItem} on owner #{((NetworkBehaviour)this).OwnerClientId} and sync");
			npc.playerBodyAnimator.SetBool("cancelHolding", true);
			npc.playerBodyAnimator.SetTrigger("Throw");
			NpcController.ThrowingObject.Value = true;
			DespawnHeldObjectOnClient();
			DespawnHeldObjectOnServerRpc();
		}

		private void DespawnHeldObjectOnClient()
		{
			PlayerControllerB npc = NpcController.Npc;
			Plugin.LogDebug($"{npc.playerUsername} Try to despawn held item on client #{((NetworkBehaviour)this).NetworkManager.LocalClientId}");
			if (AreHandsFree())
			{
				Plugin.LogError($"{npc.playerUsername} Try to despawn, but bot is holding nothing on client #{((NetworkBehaviour)this).NetworkManager.LocalClientId}");
				return;
			}
			Plugin.LogDebug($"{npc.playerUsername} Try to despawn held item {HeldItem} on client #{((NetworkBehaviour)this).NetworkManager.LocalClientId}");
			if (npc.currentItemSlot == 50)
			{
				npc.ItemOnlySlot = null;
			}
			else
			{
				npc.ItemSlots[npc.currentItemSlot] = null;
			}
			SetSpecialGrabAnimationBool(setBool: false, HeldItem);
			npc.isHoldingObject = false;
			npc.twoHanded = false;
			npc.twoHandedAnimation = false;
			npc.carryWeight = Mathf.Clamp(npc.carryWeight - (HeldItem.itemProperties.weight - 1f), 1f, 10f);
		}

		[ServerRpc]
		private void DespawnHeldObjectOnServerRpc()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Invalid comparison between Unknown and I4
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Invalid comparison between Unknown and I4
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				if (((NetworkBehaviour)this).OwnerClientId != networkManager.LocalClientId)
				{
					if ((int)networkManager.LogLevel <= 1)
					{
						Debug.LogError((object)"Only the owner can invoke a ServerRpc that requires ownership!");
					}
					return;
				}
				ServerRpcParams val = default(ServerRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(3560000878u, val, (RpcDelivery)0);
				((NetworkBehaviour)this).__endSendServerRpc(ref val2, 3560000878u, val, (RpcDelivery)0);
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
				if (!AreHandsFree())
				{
					((Component)HeldItem).gameObject.GetComponent<NetworkObject>().Despawn(true);
				}
				DespawnHeldObjectClientRpc();
			}
		}

		[ClientRpc]
		private void DespawnHeldObjectClientRpc()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val = default(ClientRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(2810675767u, val, (RpcDelivery)0);
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 2810675767u, val, (RpcDelivery)0);
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
				NpcController.ThrowingObject.Value = false;
				if (!((NetworkBehaviour)this).IsOwner)
				{
					DespawnHeldObjectOnClient();
				}
			}
		}

		private Vector3 DropItemAheadOfPlayer(GrabbableObject grabbableObject, PlayerControllerB player)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: 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_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			Ray val = default(Ray);
			((Ray)(ref val))..ctor(((Component)this).transform.position + Vector3.up * 0.4f, ((Component)player.gameplayCamera).transform.forward);
			RaycastHit val2 = default(RaycastHit);
			Vector3 val3 = ((!Physics.Raycast(val, ref val2, 1.7f, 268438273, (QueryTriggerInteraction)1)) ? ((Ray)(ref val)).GetPoint(1.7f) : ((Ray)(ref val)).GetPoint(Mathf.Clamp(((RaycastHit)(ref val2)).distance - 0.3f, 0.01f, 2f)));
			Vector3 itemFloorPosition = grabbableObject.GetItemFloorPosition(val3);
			if (itemFloorPosition == val3)
			{
				itemFloorPosition = grabbableObject.GetItemFloorPosition(default(Vector3));
			}
			return itemFloorPosition;
		}

		[ServerRpc(RequireOwnership = false)]
		private void SetObjectAsNoLongerHeldServerRpc(DropItemNetworkSerializable dropItemNetworkSerializable)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				ServerRpcParams val = default(ServerRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(1636365880u, val, (RpcDelivery)0);
				((FastBufferWriter)(ref val2)).WriteValueSafe<DropItemNetworkSerializable>(ref dropItemNetworkSerializable, default(ForNetworkSerializable));
				((NetworkBehaviour)this).__endSendServerRpc(ref val2, 1636365880u, val, (RpcDelivery)0);
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
				NetworkObject val3 = default(NetworkObject);
				if (((NetworkObjectReference)(ref dropItemNetworkSerializable.GrabbedObject)).TryGet(ref val3, (NetworkManager)null))
				{
					SetObjectAsNoLongerHeldClientRpc(dropItemNetworkSerializable);
				}
				else
				{
					Plugin.LogError($"Lethal Bot {NpcController.Npc.playerUsername} on client #{((NetworkBehaviour)this).NetworkManager.LocalClientId} (server) drop item : Object was not thrown because it does not exist on the server.");
				}
			}
		}

		[ClientRpc]
		private void SetObjectAsNoLongerHeldClientRpc(DropItemNetworkSerializable dropItemNetworkSerializable)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a3: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val = default(ClientRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(1141501747u, val, (RpcDelivery)0);
				((FastBufferWriter)(ref val2)).WriteValueSafe<DropItemNetworkSerializable>(ref dropItemNetworkSerializable, default(ForNetworkSerializable));
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 1141501747u, val, (RpcDelivery)0);
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
				NpcController.ThrowingObject.Value = false;
				ulong? skipPlayer = dropItemNetworkSerializable.SkipPlayer;
				NetworkObject val3 = default(NetworkObject);
				if (skipPlayer.HasValue && skipPlayer.Value == ((NetworkBehaviour)this).NetworkManager.LocalClientId)
				{
					Plugin.LogDebug($"{NpcController.Npc.playerUsername} skipping drop held item, on client #{((NetworkBehaviour)this).NetworkManager.LocalClientId}");
				}
				else if (AreHandsFree())
				{
					Plugin.LogDebug($"{NpcController.Npc.playerUsername} held item already dropped, on client #{((NetworkBehaviour)this).NetworkManager.LocalClientId}");
				}
				else if (((NetworkObjectReference)(ref dropItemNetworkSerializable.GrabbedObject)).TryGet(ref val3, (NetworkManager)null))
				{
					SetObjectAsNoLongerHeld(((Component)val3).GetComponent<GrabbableObject>(), dropItemNetworkSerializable.DroppedInElevator, dropItemNetworkSerializable.DroppedInShipRoom, dropItemNetworkSerializable.TargetFloorPosition, dropItemNetworkSerializable.FloorYRot);
				}
				else
				{
					Plugin.LogError($"Lethal Bot {NpcController.Npc.playerUsername} on client #{((NetworkBehaviour)this).NetworkManager.LocalClientId} drop item : The server did not have a reference to the held object");
				}
			}
		}

		private void SetObjectAsNoLongerHeld(GrabbableObject grabbableObject, bool droppedInElevator, bool droppedInShipRoom, Vector3 targetFloorPosition, int floorYRot = -1)
		{
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			grabbableObject.heldByPlayerOnServer = false;
			grabbableObject.parentObject = null;
			if (droppedInElevator)
			{
				((Component)grabbableObject).transform.SetParent(NpcController.Npc.playersManager.elevatorTransform, true);
			}
			else
			{
				((Component)grabbableObject).transform.SetParent(NpcController.Npc.playersManager.propsContainer, true);
			}
			NpcController.Npc.SetItemInElevator(droppedInShipRoom, droppedInElevator, grabbableObject);
			grabbableObject.EnablePhysics(true);
			grabbableObject.EnableItemMeshes(true);
			grabbableObject.isHeld = false;
			grabbableObject.isPocketed = false;
			grabbableObject.fallTime = 0f;
			grabbableObject.startFallingPosition = ((Component)grabbableObject).transform.parent.InverseTransformPoint(((Component)grabbableObject).transform.position);
			grabbableObject.targetFloorPosition = targetFloorPosition;
			grabbableObject.floorYRot = floorYRot;
			EndDropItem(grabbableObject);
		}

		[ServerRpc(RequireOwnership = false)]
		private void PlaceGrabbableObjectServerRpc(PlaceItemNetworkSerializable placeItemNetworkSerializable)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				ServerRpcParams val = default(ServerRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(3223226838u, val, (RpcDelivery)0);
				((FastBufferWriter)(ref val2)).WriteValueSafe<PlaceItemNetworkSerializable>(ref placeItemNetworkSerializable, default(ForNetworkSerializable));
				((NetworkBehaviour)this).__endSendServerRpc(ref val2, 3223226838u, val, (RpcDelivery)0);
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
				NetworkObject val3 = default(NetworkObject);
				NetworkObject val4 = default(NetworkObject);
				NetworkObject val5 = default(NetworkObject);
				NetworkObject val6 = default(NetworkObject);
				if (((NetworkObjectReference)(ref placeItemNetworkSerializable.GrabbedObject)).TryGet(ref val3, (NetworkManager)null) && ((NetworkObjectReference)(ref placeItemNetworkSerializable.ParentObject)).TryGet(ref val4, (NetworkManager)null))
				{
					PlaceGrabbableObjectClientRpc(placeItemNetworkSerializable);
				}
				else if (!((NetworkObjectReference)(ref placeItemNetworkSerializable.GrabbedObject)).TryGet(ref val5, (NetworkManager)null))
				{
					Plugin.LogError($"Object placement not synced to clients, missing reference to a network object: placing object with id: {((NetworkObjectReference)(ref placeItemNetworkSerializable.GrabbedObject)).NetworkObjectId}; lethalBot {NpcController.Npc.playerUsername}");
				}
				else if (!((NetworkObjectReference)(ref placeItemNetworkSerializable.ParentObject)).TryGet(ref val6, (NetworkManager)null))
				{
					Plugin.LogError($"Object placement not synced to clients, missing reference to a network object: parent object with id: {((NetworkObjectReference)(ref placeItemNetworkSerializable.ParentObject)).NetworkObjectId}; lethalBot {NpcController.Npc.playerUsername}");
				}
			}
		}

		[ClientRpc]
		private void PlaceGrabbableObjectClientRpc(PlaceItemNetworkSerializable placeItemNetworkSerializable)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0178: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val = default(ClientRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(2538662570u, val, (RpcDelivery)0);
				((FastBufferWriter)(ref val2)).WriteValueSafe<PlaceItemNetworkSerializable>(ref placeItemNetworkSerializable, default(ForNetworkSerializable));
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 2538662570u, val, (RpcDelivery)0);
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 || (!networkManager.IsClient && !networkManager.IsHost))
			{
				return;
			}
			((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
			NpcController.ThrowingObject.Value = false;
			ulong? skipPlayer = placeItemNetworkSerializable.SkipPlayer;
			NetworkObject val3 = default(NetworkObject);
			if (skipPlayer.HasValue && skipPlayer.Value == ((NetworkBehaviour)this).NetworkManager.LocalClientId)
			{
				Plugin.LogDebug($"{NpcController.Npc.playerUsername} skipping place held item, on client #{((NetworkBehaviour)this).NetworkManager.LocalClientId}");
			}
			else if (((NetworkObjectReference)(ref placeItemNetworkSerializable.GrabbedObject)).TryGet(ref val3, (NetworkManager)null))
			{
				GrabbableObject component = ((Component)val3).GetComponent<GrabbableObject>();
				NetworkObject val4 = default(NetworkObject);
				if (((NetworkObjectReference)(ref placeItemNetworkSerializable.ParentObject)).TryGet(ref val4, (NetworkManager)null))
				{
					PlaceGrabbableObject(component, ((Component)val4).transform, placeItemNetworkSerializable.PlacePositionOffset, placeItemNetworkSerializable.MatchRotationOfParent);
				}
				else
				{
					Plugin.LogError($"Reference to parent object when placing was missing. object: {component} placed by lethalBot #{NpcController.Npc.playerUsername}");
				}
			}
			else
			{
				Plugin.LogError("The server did not have a reference to the held object (when attempting to PLACE object on client.)");
			}
		}

		private void PlaceGrabbableObject(GrabbableObject placeObject, Transform parentObject, Vector3 positionOffset, bool matchRotationOfParent)
		{
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: Unknown result type (might be due to invalid IL or missing references)
			if (AreHandsFree())
			{
				Plugin.LogDebug($"{NpcController.Npc.playerUsername} held item already placed, on client #{((NetworkBehaviour)this).NetworkManager.LocalClientId}");
				return;
			}
			PlayerPhysicsRegion componentInChildren = ((Component)parentObject).GetComponentInChildren<PlayerPhysicsRegion>();
			if ((Object)(object)componentInChildren != (Object)null && componentInChildren.allowDroppingItems)
			{
				parentObject = componentInChildren.physicsTransform;
			}
			placeObject.EnablePhysics(true);
			placeObject.EnableItemMeshes(true);
			placeObject.isHeld = false;
			placeObject.isPocketed = false;
			placeObject.heldByPlayerOnServer = false;
			NpcController.Npc.SetItemInElevator(NpcController.Npc.isInHangarShipRoom, NpcController.Npc.isInElevator, placeObject);
			placeObject.parentObject = null;
			((Component)placeObject).transform.SetParent(parentObject, true);
			placeObject.startFallingPosition = ((Component)placeObject).transform.localPosition;
			((Component)placeObject).transform.localScale = placeObject.originalScale;
			((Component)placeObject).transform.localPosition = positionOffset;
			placeObject.targetFloorPosition = positionOffset;
			if (!matchRotationOfParent)
			{
				placeObject.fallTime = 0f;
			}
			else
			{
				((Component)placeObject).transform.localEulerAngles = new Vector3(0f, 0f, 0f);
				placeObject.fallTime = 1.1f;
			}
			placeObject.OnPlaceObject();
			EndDropItem(placeObject);
		}

		private void EndDropItem(GrabbableObject grabbableObject)
		{
			grabbableObject.DiscardItemOnClient();
			SetSpecialGrabAnimationBool(setBool: false, grabbableObject);
			NpcController.Npc.playerBodyAnimator.SetBool("cancelHolding", true);
			NpcController.Npc.playerBodyAnimator.SetTrigger("Throw");
			DictJustDroppedItems[grabbableObject] = Time.realtimeSinceStartup;
			HeldItem = null;
			NpcController.Npc.isHoldingObject = false;
			NpcController.Npc.currentlyHeldObjectServer = null;
			NpcController.Npc.twoHanded = false;
			NpcController.Npc.twoHandedAnimation = false;
			NpcController.GrabbedObjectValidated = false;
			GrabbableObject[] itemSlots = NpcController.Npc.ItemSlots;
			for (int i = 0; i < itemSlots.Length; i++)
			{
				if ((Object)(object)itemSlots[i] == (Object)(object)grabbableObject)
				{
					itemSlots[i] = null;
				}
			}
			if ((Object)(object)NpcController.Npc.ItemOnlySlot == (Object)(object)grabbableObject)
			{
				NpcController.Npc.ItemOnlySlot = null;
			}
			NpcController.Npc.carryWeight = Mathf.Clamp(NpcController.Npc.carryWeight - (grabbableObject.itemProperties.weight - 1f), 1f, 10f);
			SyncBatteryLethalBot(grabbableObject, (int)(grabbableObject.insertedBattery.charge * 100f));
			Plugin.LogDebug($"{NpcController.Npc.playerUsername} dropped {grabbableObject}, on client #{((NetworkBehaviour)this).NetworkManager.LocalClientId}");
		}

		[ServerRpc(RequireOwnership = false)]
		public void SyncBatteryLethalBotServerRpc(NetworkObjectReference networkObjectReferenceGrabbableObject, int charge)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val = default(ServerRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(2156721580u, val, (RpcDelivery)0);
					((FastBufferWriter)(ref val2)).WriteValueSafe<NetworkObjectReference>(ref networkObjectReferenceGrabbableObject, default(ForNetworkSerializable));
					BytePacker.WriteValueBitPacked(val2, charge);
					((NetworkBehaviour)this).__endSendServerRpc(ref val2, 2156721580u, val, (RpcDelivery)0);
				}
				if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
					SyncBatteryLethalBotClientRpc(networkObjectReferenceGrabbableObject, charge);
				}
			}
		}

		[ClientRpc]
		private void SyncBatteryLethalBotClientRpc(NetworkObjectReference networkObjectReferenceGrabbableObject, int charge)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val = default(ClientRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(2145730745u, val, (RpcDelivery)0);
				((FastBufferWriter)(ref val2)).WriteValueSafe<NetworkObjectReference>(ref networkObjectReferenceGrabbableObject, default(ForNetworkSerializable));
				BytePacker.WriteValueBitPacked(val2, charge);
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 2145730745u, val, (RpcDelivery)0);
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 || (!networkManager.IsClient && !networkManager.IsHost))
			{
				return;
			}
			((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
			NetworkObject val3 = default(NetworkObject);
			if (!((NetworkObjectReference)(ref networkObjectReferenceGrabbableObject)).TryGet(ref val3, (NetworkManager)null))
			{
				Plugin.LogError("SyncBatteryLethalBotClientRpc : Unknown to get network object from network object reference (Grab item RPC)");
				return;
			}
			GrabbableObject component = ((Component)val3).GetComponent<GrabbableObject>();
			if ((Object)(object)component == (Object)null)
			{
				Plugin.LogError("SyncBatteryLethalBotClientRpc : Unknown to get GrabbableObject component from network object (Grab item RPC)");
			}
			else
			{
				SyncBatteryLethalBot(component, charge);
			}
		}

		private void SyncBatteryLethalBot(GrabbableObject grabbableObject, int charge)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Expected O, but got Unknown
			float num = (float)charge / 100f;
			grabbableObject.insertedBattery = new Battery(num <= 0f, num);
			grabbableObject.ChargeBatteries();
		}

		public void SendChatMessage(string message, bool bypassConfig = false)
		{
			if (!bypassConfig && !Plugin.Config.AllowBotsToChat.Value)
			{
				return;
			}
			List<string> list = new List<string>();
			string[] array = message.Split(' ');
			StringBuilder stringBuilder = new StringBuilder();
			string[] array2 = array;
			foreach (string text in array2)
			{
				if (text.Length > 49)
				{
					if (stringBuilder.Length > 0)
					{
						list.Add(stringBuilder.ToString());
						stringBuilder.Clear();
					}
					for (int j = 0; j < text.Length; j += 49)
					{
						list.Add(text.Substring(j, Math.Min(49, text.Length - j)));
					}
					continue;
				}
				int num = ((stringBuilder.Length == 0) ? text.Length : (text.Length + 1));
				if (stringBuilder.Length + num <= 49)
				{
					if (stringBuilder.Length > 0)
					{
						stringBuilder.Append(' ');
					}
					stringBuilder.Append(text);
				}
				else
				{
					list.Add(stringBuilder.ToString());
					stringBuilder.Clear();
					stringBuilder.Append(text);
				}
			}
			if (stringBuilder.Length > 0)
			{
				list.Add(stringBuilder.ToString());
			}
			foreach (string item in list)
			{
				HUDManagerPatch.AddPlayerChatMessageServerRpc_ReversePatch(HUDManager.Instance, item, (int)NpcController.Npc.playerClientId);
			}
		}

		public void CallPlayer(PlayerControllerB player)
		{
			if (!((NetworkBehaviour)this).IsOwner)
			{
				return;
			}
			PlayerPhone ourPlayerPhone = GetOurPlayerPhone();
			if ((Object)(object)ourPlayerPhone == (Object)null)
			{
				Plugin.LogError("Lethal Bot " + NpcController.Npc.playerUsername + " tried to call a player, but was unable to find their phone!");
				return;
			}
			Transform transform = ((Component)player).transform;
			object obj;
			if (transform == null)
			{
				obj = null;
			}
			else
			{
				Transform obj2 = transform.Find("PhonePrefab(Clone)");
				obj = ((obj2 != null) ? ((Component)obj2).GetComponent<PlayerPhone>() : null);
			}
			PlayerPhone val = (PlayerPhone)obj;
			if ((Object)(object)val == (Object)null)
			{
				Plugin.LogError("Lethal Bot " + NpcController.Npc.playerUsername + " tried to call player " + player.playerUsername + ", but was unable to find their phone!");
			}
			else
			{
				if (lethalPhonesCoroutine != null)
				{
					((MonoBehaviour)this).StopCoroutine(lethalPhonesCoroutine);
				}
				lethalPhonesCoroutine = ((MonoBehaviour)this).StartCoroutine(callPlayerCoroutine((NetworkBehaviour)(object)ourPlayerPhone, (NetworkBehaviour)(object)val));
			}
		}

		public void HangupPhone()
		{
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			//IL_0109: Unknown result type (might be due to invalid IL or missing references)
			if (!((NetworkBehaviour)this).IsOwner)
			{
				return;
			}
			PlayerPhone ourPlayerPhone = GetOurPlayerPhone();
			if ((Object)(object)ourPlayerPhone == (Object)null)
			{
				Plugin.LogError("Lethal Bot " + NpcController.Npc.playerUsername + " tried to hangup phone, but was unable to find their phone!");
				return;
			}
			NetworkVariable<short> val = (NetworkVariable<short>)PhoneBehaviorPatch.incomingCall.GetValue(ourPlayerPhone);
			NetworkVariable<short> val2 = (NetworkVariable<short>)PhoneBehaviorPatch.activeCall.GetValue(ourPlayerPhone);
			NetworkVariable<short> val3 = (NetworkVariable<short>)PhoneBehaviorPatch.outgoingCall.GetValue(ourPlayerPhone);
			if (val.Value != -1)
			{
				PhoneNetworkHandler.Instance.HangUpCallServerRpc(val.Value, ((NetworkBehaviour)ourPlayerPhone).NetworkObjectId, default(ServerRpcParams));
				((PhoneBehavior)ourPlayerPhone).StopRingingServerRpc();
				((PhoneBehavior)ourPlayerPhone).PlayHangupSoundServerRpc();
				val.Value = -1;
			}
			else if (val2.Value != -1)
			{
				PhoneNetworkHandler.Instance.HangUpCallServerRpc(val2.Value, ((NetworkBehaviour)ourPlayerPhone).NetworkObjectId, default(ServerRpcParams));
				((PhoneBehavior)ourPlayerPhone).PlayHangupSoundServerRpc();
				val2.Value = -1;
			}
			else if (val3.Value != -1)
			{
				PhoneNetworkHandler.Instance.HangUpCallServerRpc(val3.Value, ((NetworkBehaviour)ourPlayerPhone).NetworkObjectId, default(ServerRpcParams));
				((PhoneBehavior)ourPlayerPhone).PlayHangupSoundServerRpc();
				val3.Value = -1;
			}
			ourPlayerPhone.ToggleServerPhoneModelServerRpc(false);
		}

		public void AcceptIncomingCall()
		{
			if (!((NetworkBehaviour)this).IsOwner)
			{
				return;
			}
			PlayerPhone ourPlayerPhone = GetOurPlayerPhone();
			if ((Object)(object)ourPlayerPhone == (Object)null)
			{
				Plugin.LogError("Lethal Bot " + NpcController.Npc.playerUsername + " tried to accept an incoming call, but was unable to find their phone!");
				return;
			}
			if (lethalPhonesCoroutine != null)
			{
				((MonoBehaviour)this).StopCoroutine(lethalPhonesCoroutine);
			}
			lethalPhonesCoroutine = ((MonoBehaviour)this).StartCoroutine(pickupCallCoroutine((NetworkBehaviour)(object)ourPlayerPhone));
		}

		public bool HasIncomingCall()
		{
			PlayerPhone ourPlayerPhone = GetOurPlayerPhone();
			if ((Object)(object)ourPlayerPhone == (Object)null)
			{
				Plugin.LogError("Lethal Bot " + NpcController.Npc.playerUsername + " tried to check for incoming call, but was unable to find their phone!");
				return false;
			}
			NetworkVariable<short> val = (NetworkVariable<short>)PhoneBehaviorPatch.incomingCall.GetValue(ourPlayerPhone);
			return val.Value != -1;
		}

		public bool IsCallingPlayer()
		{
			PlayerPhone ourPlayerPhone = GetOurPlayerPhone();
			if ((Object)(object)ourPlayerPhone == (Object)null)
			{
				Plugin.LogError("Lethal Bot " + NpcController.Npc.playerUsername + " tried to check if calling player, but was unable to find their phone!");
				return false;
			}
			NetworkVariable<short> val = (NetworkVariable<short>)PhoneBehaviorPatch.outgoingCall.GetValue(ourPlayerPhone);
			return val.Value != -1;
		}

		public bool AreWeInCall()
		{
			PlayerPhone ourPlayerPhone = GetOurPlayerPhone();
			if ((Object)(object)ourPlayerPhone == (Object)null)
			{
				Plugin.LogError("Lethal Bot " + NpcController.Npc.playerUsername + " tried to check if in call, but was unable to find their phone!");
				return false;
			}
			return ((PhoneBehavior)ourPlayerPhone).IsBusy();
		}

		[IteratorStateMachine(typeof(<callPlayerCoroutine>d__265))]
		private IEnumerator callPlayerCoroutine(NetworkBehaviour ourPhoneNetworkBehavior, NetworkBehaviour targetPhoneNetworkBehavior)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <callPlayerCoroutine>d__265(0)
			{
				<>4__this = this,
				ourPhoneNetworkBehavior = ourPhoneNetworkBehavior,
				targetPhoneNetworkBehavior = targetPhoneNetworkBehavior
			};
		}

		[IteratorStateMachine(typeof(<pickupCallCoroutine>d__266))]
		private IEnumerator pickupCallCoroutine(NetworkBehaviour ourPhoneNetworkBehavior)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <pickupCallCoroutine>d__266(0)
			{
				<>4__this = this,
				ourPhoneNetworkBehavior = ourPhoneNetworkBehavior
			};
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public bool IsLethalPhonesCoroutineRunning()
		{
			return lethalPhonesCoroutine != null;
		}

		public void StopLethalPhonesCoroutine()
		{
			if (lethalPhonesCoroutine != null)
			{
				((MonoBehaviour)this).StopCoroutine(lethalPhonesCoroutine);
				lethalPhonesCoroutine = null;
			}
		}

		public bool IsPhoneEquipped()
		{
			PlayerPhone ourPlayerPhone = GetOurPlayerPhone();
			if ((Object)(object)ourPlayerPhone == (Object)null)
			{
				Plugin.LogError("Lethal Bot " + NpcController.Npc.playerUsername + " tried to check if phone equipped, but was unable to find their phone!");
				return false;
			}
			return ((RigConstraint<ChainIKConstraintJob, ChainIKConstraintData, ChainIKConstraintJobBinder<ChainIKConstraintData>>)(object)PhoneBehaviorPatch.GetServerLeftArmRig(ourPlayerPhone)).weight >= 1f;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public PlayerPhone? GetOurPlayerPhone()
		{
			Transform transform = ((Component)NpcController.Npc).transform;
			if (transform == null)
			{
				return null;
			}
			Transform obj = transform.Find("PhonePrefab(Clone)");
			if (obj == null)
			{
				return null;
			}
			return ((Component)obj).GetComponent<PlayerPhone>();
		}

		public void BecomeSwitchboardOperator()
		{
			if (!((NetworkBehaviour)this).IsOwner)
			{
				return;
			}
			SwitchboardPhone val = PhoneNetworkHandler.Instance?.switchboard;
			if (!((Object)(object)val == (Object)null))
			{
				PlayerControllerB switchboardOperator = val.switchboardOperator;
				if (!((Object)(object)switchboardOperator != (Object)null))
				{
					val.OperatorSwitch(NpcController.Npc);
				}
			}
		}

		public void StopBeingSwitchboardOperator()
		{
			if (!((NetworkBehaviour)this).IsOwner)
			{
				return;
			}
			SwitchboardPhone val = PhoneNetworkHandler.Instance?.switchboard;
			if (!((Object)(object)val == (Object)null))
			{
				PlayerControllerB switchboardOperator = val.switchboardOperator;
				if (!((Object)(object)switchboardOperator == (Object)null) && !((Object)(object)switchboardOperator != (Object)(object)NpcController.Npc))
				{
					val.OperatorSwitch(NpcController.Npc);
				}
			}
		}

		public void EnterTerminal()
		{
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			Terminal terminal = TerminalManager.Instance.GetTerminal();
			if ((Object)(object)terminal == (Object)null)
			{
				Plugin.LogError("[ERROR] Bot " + NpcController.Npc.playerUsername + " was unable to find the terminal!");
				return;
			}
			InteractTrigger component = ((Component)terminal).gameObject.GetComponent<InteractTrigger>();
			((MonoBehaviour)terminal).StartCoroutine(waitUntilFrameEndToSetActive(active: true, terminal));
			PlayerControllerB npc = NpcController.Npc;
			InteractTriggerPatch.UpdateUsedByPlayerServerRpc_ReversePatch(component, (int)npc.playerClientId);
			npc.inSpecialInteractAnimation = true;
			npc.currentTriggerInAnimationWith = component;
			npc.inTerminalMenu = true;
			npc.playerBodyAnimator.ResetTrigger(component.animationString);
			npc.playerBodyAnimator.SetTrigger(component.animationString);
			npc.Crouch(false);
			npc.UpdateSpecialAnimationValue(true, (short)component.playerPositionNode.eulerAngles.y, 0f, false);
			if (Object.op_Implicit((Object)(object)component.overridePlayerParent))
			{
				npc.overridePhysicsParent = component.overridePlayerParent;
			}
			terminal.LoadNewNode(terminal.terminalNodes.specialNodes[13]);
			ref bool reference = ref PatchesUtil.usedTerminalThisSessionField.Invoke(terminal);
			if (!reference)
			{
				reference = true;
				if (!PatchesUtil.syncedTerminalValuesField.Invoke(terminal))
				{
					terminal.SyncTerminalValuesServerRpc();
				}
			}
			terminal.SetTerminalInUseLocalClient(true);
			component.interactable = false;
			terminal.terminalAudio.PlayOneShot(terminal.enterTerminalSFX);
		}

		public void LeaveTerminal(bool syncTerminalInUse = true, bool forceEndUse = false)
		{
			Terminal terminal = TerminalManager.Instance.GetTerminal();
			if ((Object)(object)terminal == (Object)null)
			{
				NpcController.Npc.inTerminalMenu = false;
				NpcController.Npc.playerBodyAnimator.ResetTrigger("Terminal");
				Plugin.LogError("[ERROR] Bot " + NpcController.Npc.playerUsername + " was unable to properly leave the terminal. Issues may occur!");
				return;
			}
			PlayerControllerB npc = NpcController.Npc;
			if (!npc.inTerminalMenu && !forceEndUse)
			{
				Plugin.LogWarning("Bot " + npc.playerUsername + " was told to leave a terminal when they were not using it!");
				return;
			}
			InteractTrigger component = ((Component)terminal).gameObject.GetComponent<InteractTrigger>();
			InteractTriggerPatch.StopUsingServerRpc_ReversePatch(component, (int)npc.playerClientId);
			((MonoBehaviour)terminal).StartCoroutine(waitUntilFrameEndToSetActive(active: false, terminal));
			npc.inSpecialInteractAnimation = false;
			npc.currentTriggerInAnimationWith = null;
			npc.inTerminalMenu = false;
			npc.playerBodyAnimator.ResetTrigger(component.animationString);
			if (component.stopAnimationManually)
			{
				npc.playerBodyAnimator.SetTrigger(component.stopAnimationString);
			}
			npc.UpdateSpecialAnimationValue(false, (short)0, 0f, false);
			if (Object.op_Implicit((Object)(object)component.overridePlayerParent) && (Object)(object)npc.overridePhysicsParent == (Object)(object)component.overridePlayerParent)
			{
				npc.overridePhysicsParent = null;
			}
			terminal.timeSinceTerminalInUse = 0f;
			component.interactable = true;
			Plugin.LogDebug($"Quit terminal; inTerminalMenu true?: {npc.inTerminalMenu}");
			if (syncTerminalInUse)
			{
				terminal.SetTerminalInUseLocalClient(false);
			}
			terminal.terminalAudio.PlayOneShot(terminal.leaveTerminalSFX);
		}

		[IteratorStateMachine(typeof(<waitUntilFrameEndToSetActive>d__275))]
		private IEnumerator waitUntilFrameEndToSetActive(bool active, Terminal? ourTerminal)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <waitUntilFrameEndToSetActive>d__275(0)
			{
				active = active,
				ourTerminal = ourTerminal
			};
		}

		public float GetLightLevelAroundBot()
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			Vector3 position = ((Component)NpcController.Npc.gameplayCamera).transform.position;
			float num = 0f;
			int num2 = 0;
			foreach (Light item in LethalBotManager.LightsOnMap)
			{
				if (ShouldIgnoreLightSource(item))
				{
					continue;
				}
				Vector3 val = position - ((Component)item).transform.position;
				float num3 = 1f;
				if ((int)item.type == 0)
				{
					float num4 = Vector3.Angle(((Component)item).transform.forward, ((Vector3)(ref val)).normalized);
					float num5 = item.spotAngle * 0.5f;
					if (num4 > num5)
					{
						continue;
					}
					num3 = Mathf.Clamp01(num3 - num4 / num5);
				}
				float magnitude = ((Vector3)(ref val)).magnitude;
				if (!(magnitude > item.range))
				{
					float num6 = 1f - Mathf.Clamp01(magnitude / item.range);
					num6 *= num6;
					float lightOcclusionFactor = GetLightOcclusionFactor(((Component)item).transform.position, position);
					num += item.intensity * num6 * num3 * lightOcclusionFactor;
					num2++;
				}
			}
			return num / (float)((num2 <= 0) ? 1 : num2);
		}

		internal static bool ShouldIgnoreLightSource([NotNullWhen(false)] Light? light)
		{
			if ((Object)(object)light == (Object)null || !((Behaviour)light).enabled || light.intensity <= 0f)
			{
				return true;
			}
			return false;
		}

		internal static float GetLightOcclusionFactor(Vector3 lightPos, Vector3 targetPos)
		{
			//IL_0008: 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_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			StartOfRound instance = StartOfRound.Instance;
			int num = 0;
			Vector3 val = targetPos - lightPos;
			Vector3 normalized = ((Vector3)(ref val)).normalized;
			Vector3 val2 = Vector3.Cross(normalized, Vector3.up);
			if (((Vector3)(ref val2)).sqrMagnitude < 0.01f)
			{
				val2 = Vector3.Cross(normalized, Vector3.forward);
			}
			val2 = ((Vector3)(ref val2)).normalized * 0.2f;
			if (Physics.Linecast(lightPos, targetPos, instance.collidersAndRoomMaskAndDefault))
			{
				num++;
			}
			if (Physics.Linecast(lightPos + val2, targetPos, instance.collidersAndRoomMaskAndDefault))
			{
				num++;
			}
			if (Physics.Linecast(lightPos - val2, targetPos, instance.collidersAndRoomMaskAndDefault))
			{
				num++;
			}
			float num2 = 1f - (float)num / 3f;
			return Mathf.Max(num2, 0.15f);
		}

		public override void EnableEnemyMesh(bool enable, bool overrideDoNotSet = false, bool tamperWithMeshes = false)
		{
		}

		public override void HitEnemy(int force = 1, PlayerControllerB playerWhoHit = null, bool playHitSFX = false, int hitID = -1)
		{
		}

		public override void SetEnemyStunned(bool setToStunned, float setToStunTime = 1f, PlayerControllerB setStunnedByPlayer = null)
		{
		}

		public void DamageLethalBot(int damageNumber, bool hasDamageSFX = true, bool callRPC = true, CauseOfDeath causeOfDeath = 0, int deathAnimation = 0, bool fallDamage = false, Vector3 force = default(Vector3))
		{
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			PlayerControllerB npc = NpcController.Npc;
			Plugin.LogDebug($"DamageLethalBot for LOCAL client #{((NetworkBehaviour)this).NetworkManager.LocalClientId}, lethalBot object: Bot #{BotId} {npc.playerUsername},\r\n                            damageNumber {damageNumber}, causeOfDeath {causeOfDeath}, deathAnimation {deathAnimation}, fallDamage {fallDamage}, force {force}");
			if (!((NetworkBehaviour)this).IsOwner || npc.isPlayerDead || !npc.AllowPlayerDeath())
			{
				return;
			}
			if (npc.health - damageNumber <= 0 && !npc.criticallyInjured && damageNumber < MaxHealthPercent(50) && MaxHealthPercent(10) != MaxHealthPercent(20))
			{
				npc.health = MaxHealthPercent(5);
			}
			else
			{
				npc.health = Mathf.Clamp(npc.health - damageNumber, 0, MaxHealth);
			}
			if (npc.health <= 0)
			{
				bool flag = deathAnimation != -1;
				npc.KillPlayer(force, flag, causeOfDeath, deathAnimation, default(Vector3), false);
			}
			else
			{
				if ((npc.health < MaxHealthPercent(10) || npc.health == MaxHealthPercent(5)) && !npc.criticallyInjured)
				{
					npc.MakeCriticallyInjured(true);
				}
				else
				{
					if (damageNumber >= MaxHealthPercent(10))
					{
						npc.sprintMeter = Mathf.Clamp(npc.sprintMeter + (float)damageNumber / 125f, 0f, 1f);
					}
					if (callRPC)
					{
						if (((NetworkBehaviour)this).IsServer)
						{
							npc.DamagePlayerClientRpc(damageNumber, npc.health);
						}
						else
						{
							npc.DamagePlayerServerRpc(damageNumber, npc.health);
						}
					}
				}
				if (fallDamage)
				{
					npc.movementAudio.PlayOneShot(StartOfRound.Instance.fallDamageSFX, 1f);
					WalkieTalkie.TransmitOneShotAudio(npc.movementAudio, StartOfRound.Instance.fallDamageSFX, 1f);
					npc.BreakLegsSFXClientRpc();
				}
				else if (hasDamageSFX)
				{
					npc.movementAudio.PlayOneShot(StartOfRound.Instance.damageSFX, 1f);
				}
				LethalBotIdentity.Voice.TryPlayVoiceAudio(new PlayVoiceParameters
				{
					VoiceState = EnumVoicesState.Hit,
					CanTalkIfOtherLethalBotTalk = true,
					WaitForCooldown = false,
					CutCurrentVoiceStateToTalk = true,
					CanRepeatVoiceState = true,
					ShouldSync = true,
					IsLethalBotInside = npc.isInsideFactory,
					AllowSwearing = Plugin.Config.AllowSwearing.Value
				});
			}
			npc.takingFallDamage = false;
			if (!npc.inSpecialInteractAnimation && !npc.twoHandedAnimation)
			{
				npc.playerBodyAnimator.SetTrigger("Damage");
			}
			npc.specialAnimationWeight = 1f;
			npc.PlayQuickSpecialAnimation(0.7f);
		}

		public void HealthRegen()
		{
			if (NpcController.LimpMultiplier > 0f)
			{
				NpcController.LimpMultiplier -= Time.deltaTime / 1.8f;
			}
			PlayerControllerB npc = NpcController.Npc;
			if (npc.health >= MaxHealthPercent(20) && npc.health != MaxHealthPercent(5))
			{
				return;
			}
			if (npc.healthRegenerateTimer <= 0f)
			{
				npc.healthRegenerateTimer = healthRegenerateTimerMax;
				npc.health = ((npc.health + 1 > MaxHealth) ? MaxHealth : (npc.health + 1));
				if (((NetworkBehaviour)this).IsOwner && npc.criticallyInjured && (npc.health >= MaxHealthPercent(20) || MaxHealth == 1))
				{
					npc.MakeCriticallyInjured(false);
				}
			}
			else
			{
				npc.healthRegenerateTimer -= Time.deltaTime;
			}
		}

		public override void KillEnemy(bool destroy = false)
		{
		}

		internal void KillLethalBot(Vector3 bodyVelocity, bool spawnBody, CauseOfDeath causeOfDeath, int deathAnimation, Vector3 positionOffset, bool setOverrideDropItems)
		{
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_036b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0374: Unknown result type (might be due to invalid IL or missing references)
			//IL_037a: Expected I4, but got Unknown
			//IL_0387: Unknown result type (might be due to invalid IL or missing references)
			//IL_0412: Unknown result type (might be due to invalid IL or missing references)
			//IL_0418: Unknown result type (might be due to invalid IL or missing references)
			//IL_041b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0421: Unknown result type (might be due to invalid IL or missing references)
			//IL_0424: Unknown result type (might be due to invalid IL or missing references)
			//IL_042a: Unknown result type (might be due to invalid IL or missing references)
			//IL_042d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0433: Unknown result type (might be due to invalid IL or missing references)
			//IL_0436: Unknown result type (might be due to invalid IL or missing references)
			//IL_043c: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_03de: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0266: Unknown result type (might be due to invalid IL or missing references)
			//IL_0267: Unknown result type (might be due to invalid IL or missing references)
			//IL_026d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0274: Expected I4, but got Unknown
			//IL_0527: Unknown result type (might be due to invalid IL or missing references)
			//IL_052d: Expected I4, but got Unknown
			PlayerControllerB npc = NpcController.Npc;
			if (!((NetworkBehaviour)npc).IsOwner || npc.isPlayerDead || !npc.AllowPlayerDeath())
			{
				return;
			}
			Plugin.LogInfo($"KillLethalBot for LOCAL client #{((NetworkBehaviour)this).NetworkManager.LocalClientId}, lethalBot object: Bot #{BotId} {npc.playerUsername}\r\n                            bodyVelocity {bodyVelocity}, spawnBody {spawnBody}, causeOfDeath {causeOfDeath}, deathAnimation {deathAnimation}, positionOffset {positionOffset}");
			npc.overrideDontSpawnBody = false;
			npc.overrideDropItems = setOverrideDropItems;
			npc.isPlayerDead = true;
			npc.isSprinting = false;
			if (!spawnBody)
			{
				deathAnimation = -1;
			}
			((UnityEvent<PlayerControllerB, int>)(object)StartOfRound.Instance.LocalPlayerDieEvent).Invoke(npc, deathAnimation);
			npc.isPlayerControlled = false;
			((Renderer)npc.thisPlayerModelArms).enabled = false;
			npc.localVisor.position = npc.playersManager.notSpawnedPosition.position;
			npc.DisablePlayerModel(((Component)npc).gameObject, false, false);
			npc.isInsideFactory = false;
			npc.IsInspectingItem = false;
			if (npc.inTerminalMenu)
			{
				LeaveTerminal();
			}
			npc.inTerminalMenu = false;
			npc.twoHanded = false;
			npc.isHoldingObject = false;
			npc.currentlyHeldObjectServer = null;
			npc.carryWeight = 1f;
			npc.fallValue = 0f;
			npc.fallValueUncapped = 0f;
			npc.takingFallDamage = false;
			StopSinkingState();
			NpcController.DrowningTimer = 1f;
			npc.sinkingValue = 0f;
			npc.hinderedMultiplier = 1f;
			npc.isMovementHindered = 0;
			npc.inAnimationWithEnemy = null;
			PatchesUtil.positionOfDeathField.Invoke(npc) = ((Component)npc).transform.position;
			npc.bleedingHeavily = false;
			npc.setPositionOfDeadPlayer = true;
			npc.snapToServerPosition = false;
			npc.causeOfDeath = causeOfDeath;
			npc.drunkness = 0f;
			npc.drunknessInertia = 0f;
			npc.poison = 0f;
			npc.poisonInertia = 0f;
			npc.slipperyFloor = 0f;
			npc.slimeSlipAudio.Stop();
			PatchesUtil.slimeSlipAudioVolumeSyncField.Invoke(npc) = 0f;
			((Component)npc.slimeOnFaceDecals[0]).gameObject.SetActive(false);
			((Component)npc.slimeOnFaceDecals[1]).gameObject.SetActive(false);
			if (spawnBody && !npc.overrideDontSpawnBody)
			{
				npc.SpawnDeadBody((int)npc.playerClientId, bodyVelocity, (int)causeOfDeath, npc, deathAnimation, (Transform)null, (Transform)null, positionOffset);
				if ((Object)(object)npc.deadBody != (Object)null)
				{
					LethalBotIdentity.DeadBody = npc.deadBody;
					GrabbableObject val = npc.deadBody?.grabBodyObject;
					if ((Object)(object)val != (Object)null)
					{
						DictJustDroppedItems[val] = Time.realtimeSinceStartup;
					}
				}
				else
				{
					Plugin.LogWarning("Bot " + npc.playerUsername + " dead body was not spawned. This is probably a bug with another mod or the base game itself!");
				}
			}
			npc.physicsParent = null;
			npc.overridePhysicsParent = null;
			npc.lastSyncedPhysicsParent = null;
			NpcController.CurrentLethalBotPhysicsRegions.Clear();
			ReParentLethalBot(npc.playersManager.playersContainer);
			npc.CancelSpecialTriggerAnimations();
			SoundManager.Instance.playerVoicePitchTargets[npc.playerClientId] = 1f;
			SoundManager.Instance.playerVoicePitchLerpSpeed[npc.playerClientId] = 3f;
			PatchesUtil.KillPlayerServerRpcMethod.Invoke(npc, new object[7]
			{
				(int)npc.playerClientId,
				spawnBody,
				bodyVelocity,
				(int)causeOfDeath,
				deathAnimation,
				positionOffset,
				setOverrideDropItems
			});
			Plugin.LogInfo($"Override drop items : {npc.overrideDropItems}; overridedontspawnbody: {npc.overrideDontSpawnBody}");
			if (npc.overrideDropItems)
			{
				npc.DropAllHeldItemsAndSync(((Component)npc).transform.position, npc.serverItemHolder.position, npc.serverItemHolder.eulerAngles, npc.playerEye.position, npc.playerEye.eulerAngles);
			}
			else
			{
				npc.DropAllHeldItems(spawnBody, false, false, false, default(Vector3), default(Vector3), default(Vector3), default(Vector3), default(Vector3));
			}
			if ((Object)(object)State?.TargetItem != (Object)null)
			{
				DictJustDroppedItems[State.TargetItem] = Time.realtimeSinceStartup;
			}
			npc.DisableJetpackControlsLocally();
			NpcController.IsControllerInCruiser = false;
			if (GameNetworkManager.Instance.localPlayerController.isPlayerDead)
			{
				HUDManager.Instance.UpdateBoxesSpectateUI();
			}
			base.isEnemyDead = true;
			LethalBotIdentity.Hp = 0;
			StopOffMeshLinkMovement(warpToEnd: false);
			SetAgent(enabled: false);
			State = new BrainDeadState(this);
			Plugin.LogDebug($"Ran kill lethalBot function for LOCAL client #{((NetworkBehaviour)this).NetworkManager.LocalClientId}, lethalBot object: Bot #{BotId} {npc.playerUsername}");
			GroupManager.Instance.RemoveFromCurrentGroupAndSync(npc);
			if (Plugin.IsModReviveCompanyLoaded)
			{
				ReviveCompanySetPlayerDiedAt((int)npc.playerClientId);
			}
			if (Plugin.IsModLethalPhonesLoaded)
			{
				CallLethalPhonesDeath((int)causeOfDeath);
			}
		}

		private void ReviveCompanySetPlayerDiedAt(int playerClientId)
		{
			if (GlobalVariables.ModActivated)
			{
				GeneralUtil.SetPlayerDiedAt(playerClientId);
			}
		}

		private void CallLethalPhonesDeath(int causeOfDeath)
		{
			PlayerPhone ourPlayerPhone = GetOurPlayerPhone();
			if ((Object)(object)ourPlayerPhone == (Object)null)
			{
				Plugin.LogError("Lethal Bot " + NpcController.Npc.playerUsername + " tried to call phone death hook, but was unable to find their phone!");
			}
			else
			{
				ourPlayerPhone.Death(causeOfDeath);
			}
		}

		private void ResizeRagdoll(Transform transform)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			List<Vector3> list = new List<Vector3>();
			List<Vector3> list2 = new List<Vector3>();
			Joint[] componentsInChildren = ((Component)transform).GetComponentsInChildren<Joint>();
			foreach (Joint val in componentsInChildren)
			{
				list.Add(val.connectedAnchor);
				list2.Add(val.anchor);
			}
			transform.localScale = Vector3.one;
			for (int j = 0; j < componentsInChildren.Length; j++)
			{
				Joint val2 = componentsInChildren[j];
				val2.connectedAnchor = list[j];
				val2.anchor = list2[j];
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public bool IsSpawningAnimationRunning()
		{
			return spawnAnimationCoroutine != null;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public bool IsInSpecialAnimation()
		{
			if (!NpcController.Npc.inSpecialInteractAnimation)
			{
				return NpcController.Npc.enteringSpecialAnimation;
			}
			return true;
		}

		public Coroutine BeginLethalBotSpawnAnimation(EnumSpawnAnimation enumSpawnAnimation)
		{
			if (enumSpawnAnimation == EnumSpawnAnimation.OnlyPlayerSpawnAnimationIfDead)
			{
				enumSpawnAnimation = (LethalBotIdentity.DiedLastRound ? EnumSpawnAnimation.OnlyPlayerSpawnAnimation : EnumSpawnAnimation.None);
			}
			switch (enumSpawnAnimation)
			{
			case EnumSpawnAnimation.None:
			case EnumSpawnAnimation.ReinitializePlayer:
				return ((MonoBehaviour)this).StartCoroutine(CoroutineNoSpawnAnimation());
			case EnumSpawnAnimation.OnlyPlayerSpawnAnimation:
				return ((MonoBehaviour)this).StartCoroutine(CoroutineOnlyPlayerSpawnAnimation());
			default:
				return ((MonoBehaviour)this).StartCoroutine(CoroutineNoSpawnAnimation());
			}
		}

		[IteratorStateMachine(typeof(<CoroutineNoSpawnAnimation>d__292))]
		private IEnumerator CoroutineNoSpawnAnimation()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <CoroutineNoSpawnAnimation>d__292(0)
			{
				<>4__this = this
			};
		}

		[IteratorStateMachine(typeof(<CoroutineOnlyPlayerSpawnAnimation>d__293))]
		private IEnumerator CoroutineOnlyPlayerSpawnAnimation()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <CoroutineOnlyPlayerSpawnAnimation>d__293(0)
			{
				<>4__this = this
			};
		}

		internal AIState GetDesiredAIState()
		{
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_0155: Unknown result type (might be due to invalid IL or missing references)
			//IL_016a: Unknown result type (might be due to invalid IL or missing references)
			//IL_016f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0183: Unknown result type (might be due to invalid IL or missing references)
			//IL_0188: Unknown result type (might be due to invalid IL or missing references)
			//IL_018d: Unknown result type (might be due to invalid IL or missing references)
			//IL_019d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d5: Unknown result type (might be due to invalid IL or missing references)
			switch (LethalBotIdentity.DefaultAIState)
			{
			case EnumDefaultAIState.FollowPlayer:
				return new GetCloseToPlayerState(this, GetClosestIrlPlayer());
			case EnumDefaultAIState.SearchForScrap:
				return new SearchingForScrapState(this);
			case EnumDefaultAIState.ShipDuty:
				if ((Object)(object)LethalBotManager.Instance.MissionControlPlayer != (Object)(object)NpcController.Npc)
				{
					LethalBotManager.Instance.MissionControlPlayer = NpcController.Npc;
				}
				return new MissionControlState(this);
			case EnumDefaultAIState.TransferLoot:
				if (!LethalBotManager.Instance.LootTransferPlayers.Contains(NetworkBehaviourReference.op_Implicit((NetworkBehaviour)(object)NpcController.Npc)))
				{
					LethalBotManager.Instance.AddPlayerToLootTransferListAndSync(NetworkBehaviourReference.op_Implicit((NetworkBehaviour)(object)NpcController.Npc));
				}
				return new TransferLootState(this);
			default:
				Plugin.LogWarning("Bot " + NpcController.Npc.playerUsername + " has an invaild default AI state. Falling back to dynamic!");
				break;
			case EnumDefaultAIState.Dynamic:
				break;
			}
			PlayerControllerB closestIrlPlayer = GetClosestIrlPlayer();
			if ((NpcController.Npc.isInElevator || NpcController.Npc.isInHangarShipRoom) && (StartOfRound.Instance.shipIsLeaving || !StartOfRound.Instance.shipHasLanded))
			{
				return new GetCloseToPlayerState(this, closestIrlPlayer);
			}
			if ((Object)(object)closestIrlPlayer != (Object)null && closestIrlPlayer.isPlayerControlled && !closestIrlPlayer.isPlayerDead)
			{
				Vector3 val = Vector3.Scale(((Component)closestIrlPlayer).transform.position - ((Component)NpcController.Npc).transform.position, new Vector3(1f, 0f, 1f));
				float sqrMagnitude = ((Vector3)(ref val)).sqrMagnitude;
				val = Vector3.Scale(((Component)closestIrlPlayer).transform.position - ((Component)NpcController.Npc).transform.position, new Vector3(0f, 1f, 0f));
				float sqrMagnitude2 = ((Vector3)(ref val)).sqrMagnitude;
				if (sqrMagnitude < 625f && sqrMagnitude2 < 2500f)
				{
					return new GetCloseToPlayerState(this, closestIrlPlayer);
				}
			}
			if ((Object)(object)LethalBotManager.Instance.MissionControlPlayer == (Object)(object)NpcController.Npc)
			{
				return new MissionControlState(this);
			}
			return new SearchingForScrapState(this);
		}

		internal PlayerControllerB GetClosestIrlPlayer()
		{
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			PlayerControllerB val = null;
			float num = float.MaxValue;
			PlayerControllerB[] allPlayerScripts = StartOfRound.Instance.allPlayerScripts;
			foreach (PlayerControllerB val2 in allPlayerScripts)
			{
				if (val2.isPlayerControlled && !val2.isPlayerDead && !LethalBotManager.Instance.IsPlayerLethalBot(val2) && (!Plugin.IsModLethalInternsLoaded || !LethalBotManager.IsPlayerIntern(val2)))
				{
					Vector3 val3 = ((Component)val2).transform.position - ((Component)NpcController.Npc).transform.position;
					float sqrMagnitude = ((Vector3)(ref val3)).sqrMagnitude;
					if ((Object)(object)val == (Object)null || sqrMagnitude < num)
					{
						val = val2;
						num = sqrMagnitude;
					}
				}
			}
			return val;
		}

		private Vector3 GetRandomPushForce(Vector3 origin, Vector3 point, float forceMean)
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			point.y += Random.Range(2f, 4f);
			float num = Random.Range(forceMean * 0.5f, forceMean * 1.5f);
			return Vector3.Normalize(point - origin) * num / Vector3.Distance(point, origin);
		}

		public bool PullShipLever(StartMatchLever? shipLever)
		{
			if ((Object)(object)shipLever == (Object)null)
			{
				shipLever = Object.FindObjectOfType<StartMatchLever>();
				if ((Object)(object)shipLever == (Object)null)
				{
					return false;
				}
			}
			InteractTrigger triggerScript = shipLever.triggerScript;
			if ((Object)(object)triggerScript == (Object)null || !triggerScript.interactable || triggerScript.isPlayingSpecialAnimation)
			{
				return false;
			}
			PlayerControllerB npc = NpcController.Npc;
			if (npc.inSpecialInteractAnimation)
			{
				return false;
			}
			if (useInteractTriggerCoroutine != null)
			{
				((MonoBehaviour)this).StopCoroutine(useInteractTriggerCoroutine);
			}
			useInteractTriggerCoroutine = ((MonoBehaviour)this).StartCoroutine(pullLeverCoroutine(shipLever, triggerScript));
			return true;
		}

		[IteratorStateMachine(typeof(<pullLeverCoroutine>d__298))]
		private IEnumerator pullLeverCoroutine(StartMatchLever startMatchLever, InteractTrigger leverTrigger)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <pullLeverCoroutine>d__298(0)
			{
				<>4__this = this,
				startMatchLever = startMatchLever,
				leverTrigger = leverTrigger
			};
		}

		public void DoPullLever(StartMatchLever startMatchLever)
		{
			if (startMatchLever.leverHasBeenPulled)
			{
				startMatchLever.StartGame();
			}
			else
			{
				EndGame(startMatchLever);
			}
		}

		private void EndGame(StartMatchLever startMatchLever)
		{
			if (!NpcController.Npc.isPlayerControlled || base.isEnemyDead || NpcController.Npc.isPlayerDead)
			{
				return;
			}
			Plugin.LogDebug("Bot " + NpcController.Npc.playerUsername + " has successfuly pulled the ship lever to end the round!");
			StartOfRound playersManager = startMatchLever.playersManager;
			if (!playersManager.shipHasLanded || playersManager.shipIsLeaving || playersManager.shipLeftAutomatically)
			{
				return;
			}
			if (Plugin.IsModFacilityMeltdownLoaded)
			{
				try
				{
					Type type = AccessTools.TypeByName("FacilityMeltdown.Patches.StartMatchLeverPatch");
					if (type != null)
					{
						MethodInfo methodInfo = AccessTools.Method(type, "ShortenMeltdownTimer", (Type[])null, (Type[])null);
						if (methodInfo != null)
						{
							methodInfo.Invoke(null, null);
							Plugin.LogDebug("Successfully invoked ShortenMeltdownTimer via AccessTools.");
						}
						else
						{
							Plugin.LogWarning("Could not find ShortenMeltdownTimer method.");
						}
					}
					else
					{
						Plugin.LogWarning("Could not find StartMatchLeverPatch type from FacilityMeltdown.");
					}
				}
				catch (Exception arg)
				{
					Plugin.LogError($"Error while invoking meltdown timer shortening: {arg}");
				}
			}
			startMatchLever.triggerScript.interactable = false;
			playersManager.EndGameServerRpc((int)NpcController.Npc.playerClientId);
			playersManager.shipIsLeaving = true;
		}

		private void DoLeverAnimation(StartMatchLever startMatchLever)
		{
			if (!NpcController.Npc.isPlayerControlled || base.isEnemyDead || NpcController.Npc.isPlayerDead)
			{
				return;
			}
			StartOfRound instance = StartOfRound.Instance;
			if (!instance.travellingToNewLevel && (!instance.inShipPhase || instance.connectedPlayersAmount + 1 > 1 || startMatchLever.singlePlayerEnabled) && !instance.beganLoadingNewLevel && (SceneManager.sceneCount <= 1 || !instance.inShipPhase))
			{
				if (instance.shipHasLanded)
				{
					pullLeverAnimMethod(startMatchLever, arg2: false);
					clientSentRPCField.Invoke(startMatchLever) = true;
					startMatchLever.PlayLeverPullEffectsServerRpc(false);
				}
				else if (instance.inShipPhase)
				{
					pullLeverAnimMethod(startMatchLever, arg2: true);
					clientSentRPCField.Invoke(startMatchLever) = true;
					setStartingShipEffectsMethod(startMatchLever);
					startMatchLever.PlayLeverPullEffectsServerRpc(true);
				}
			}
		}

		public bool UseItemCharger(ItemCharger? itemCharger)
		{
			if ((Object)(object)itemCharger == (Object)null)
			{
				itemCharger = Object.FindObjectOfType<ItemCharger>();
				if ((Object)(object)itemCharger == (Object)null)
				{
					return false;
				}
			}
			if (AreHandsFree() || !HeldItem.itemProperties.requiresBattery)
			{
				return false;
			}
			InteractTrigger triggerScript = itemCharger.triggerScript;
			if ((Object)(object)triggerScript == (Object)null || triggerScript.isPlayingSpecialAnimation)
			{
				return false;
			}
			PlayerControllerB npc = NpcController.Npc;
			if (npc.inSpecialInteractAnimation)
			{
				return false;
			}
			itemCharger.PlayChargeItemEffectServerRpc((int)npc.playerClientId);
			if (useInteractTriggerCoroutine != null)
			{
				((MonoBehaviour)this).StopCoroutine(useInteractTriggerCoroutine);
			}
			useInteractTriggerCoroutine = ((MonoBehaviour)this).StartCoroutine(useItemCharger(itemCharger, triggerScript, HeldItem));
			return true;
		}

		[IteratorStateMachine(typeof(<useItemCharger>d__306))]
		private IEnumerator useItemCharger(ItemCharger itemCharger, InteractTrigger itemChargerTrigger, GrabbableObject itemToCharge)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <useItemCharger>d__306(0)
			{
				<>4__this = this,
				itemCharger = itemCharger,
				itemChargerTrigger = itemChargerTrigger,
				itemToCharge = itemToCharge
			};
		}

		public void SyncJump()
		{
			if (((NetworkBehaviour)this).IsServer)
			{
				JumpClientRpc();
			}
			else
			{
				JumpServerRpc();
			}
		}

		[ServerRpc(RequireOwnership = false)]
		private void JumpServerRpc()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val = default(ServerRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(2881373730u, val, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendServerRpc(ref val2, 2881373730u, val, (RpcDelivery)0);
				}
				if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
					JumpClientRpc();
				}
			}
		}

		[ClientRpc]
		private void JumpClientRpc()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val = default(ClientRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(1406234559u, val, (RpcDelivery)0);
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 1406234559u, val, (RpcDelivery)0);
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
				if (!IsClientOwnerOfLethalBot())
				{
					PlayerControllerBPatch.PlayJumpAudio_ReversePatch(NpcController.Npc);
				}
			}
		}

		public void SyncLandFromJump(bool fallHard)
		{
			if (((NetworkBehaviour)this).IsServer)
			{
				JumpLandFromClientRpc(fallHard);
			}
			else
			{
				JumpLandFromServerRpc(fallHard);
			}
		}

		[ServerRpc(RequireOwnership = false)]
		private void JumpLandFromServerRpc(bool fallHard)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val = default(ServerRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(3640508774u, val, (RpcDelivery)0);
					((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref fallHard, default(ForPrimitives));
					((NetworkBehaviour)this).__endSendServerRpc(ref val2, 3640508774u, val, (RpcDelivery)0);
				}
				if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
					JumpLandFromClientRpc(fallHard);
				}
			}
		}

		[ClientRpc]
		private void JumpLandFromClientRpc(bool fallHard)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val = default(ClientRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(2079473104u, val, (RpcDelivery)0);
				((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref fallHard, default(ForPrimitives));
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 2079473104u, val, (RpcDelivery)0);
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
				if (fallHard)
				{
					NpcController.Npc.movementAudio.PlayOneShot(StartOfRound.Instance.playerHitGroundHard, 1f);
				}
				else
				{
					NpcController.Npc.movementAudio.PlayOneShot(StartOfRound.Instance.playerHitGroundSoft, 0.7f);
				}
			}
		}

		public void SyncChangeSinkingState(bool startSinking, float sinkingSpeed = 0f, int audioClipIndex = 0)
		{
			if (((NetworkBehaviour)this).IsServer)
			{
				ChangeSinkingStateClientRpc(startSinking, sinkingSpeed, audioClipIndex);
			}
			else
			{
				ChangeSinkingStateServerRpc(startSinking, sinkingSpeed, audioClipIndex);
			}
		}

		[ServerRpc]
		private void ChangeSinkingStateServerRpc(bool startSinking, float sinkingSpeed, int audioClipIndex)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: Invalid comparison between Unknown and I4
			//IL_014a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Invalid comparison between Unknown and I4
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				if (((NetworkBehaviour)this).OwnerClientId != networkManager.LocalClientId)
				{
					if ((int)networkManager.LogLevel <= 1)
					{
						Debug.LogError((object)"Only the owner can invoke a ServerRpc that requires ownership!");
					}
					return;
				}
				ServerRpcParams val = default(ServerRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(1619705390u, val, (RpcDelivery)0);
				((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref startSinking, default(ForPrimitives));
				((FastBufferWriter)(ref val2)).WriteValueSafe<float>(ref sinkingSpeed, default(ForPrimitives));
				BytePacker.WriteValueBitPacked(val2, audioClipIndex);
				((NetworkBehaviour)this).__endSendServerRpc(ref val2, 1619705390u, val, (RpcDelivery)0);
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
				ChangeSinkingStateClientRpc(startSinking, sinkingSpeed, audioClipIndex);
			}
		}

		[ClientRpc]
		private void ChangeSinkingStateClientRpc(bool startSinking, float sinkingSpeed, int audioClipIndex)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val = default(ClientRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(3427657121u, val, (RpcDelivery)0);
				((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref startSinking, default(ForPrimitives));
				((FastBufferWriter)(ref val2)).WriteValueSafe<float>(ref sinkingSpeed, default(ForPrimitives));
				BytePacker.WriteValueBitPacked(val2, audioClipIndex);
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 3427657121u, val, (RpcDelivery)0);
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
				if (startSinking)
				{
					NpcController.Npc.sinkingSpeedMultiplier = sinkingSpeed;
					NpcController.Npc.isSinking = true;
					NpcController.Npc.statusEffectAudio.clip = StartOfRound.Instance.statusEffectClips[audioClipIndex];
					NpcController.Npc.statusEffectAudio.Play();
				}
				else
				{
					StopSinkingState();
				}
			}
		}

		public void StopSinkingState()
		{
			NpcController.Npc.isSinking = false;
			NpcController.Npc.statusEffectAudio.Stop();
			NpcController.Npc.voiceMuffledByEnemy = false;
			NpcController.Npc.sourcesCausingSinking = 0;
			NpcController.Npc.isMovementHindered = 0;
			NpcController.Npc.hinderedMultiplier = 1f;
			NpcController.Npc.isUnderwater = false;
			NpcController.Npc.underwaterCollider = null;
		}

		public void SyncDisableJetpackMode()
		{
			if (((NetworkBehaviour)this).IsServer)
			{
				DisableJetpackModeClientRpc();
			}
			else
			{
				DisableJetpackModeServerRpc();
			}
		}

		[ServerRpc]
		private void DisableJetpackModeServerRpc()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Invalid comparison between Unknown and I4
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Invalid comparison between Unknown and I4
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				if (((NetworkBehaviour)this).OwnerClientId != networkManager.LocalClientId)
				{
					if ((int)networkManager.LogLevel <= 1)
					{
						Debug.LogError((object)"Only the owner can invoke a ServerRpc that requires ownership!");
					}
					return;
				}
				ServerRpcParams val = default(ServerRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(71921022u, val, (RpcDelivery)0);
				((NetworkBehaviour)this).__endSendServerRpc(ref val2, 71921022u, val, (RpcDelivery)0);
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
				DisableJetpackModeClientRpc();
			}
		}

		[ClientRpc]
		private void DisableJetpackModeClientRpc()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val = default(ClientRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(4175123208u, val, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendClientRpc(ref val2, 4175123208u, val, (RpcDelivery)0);
				}
				if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
					NpcController.Npc.DisableJetpackControlsLocally();
				}
			}
		}

		public void SyncStopPerformingEmote()
		{
			if (((NetworkBehaviour)this).IsServer)
			{
				StopPerformingEmoteClientRpc();
			}
			else
			{
				StopPerformingEmoteServerRpc();
			}
		}

		[ServerRpc(RequireOwnership = false)]
		private void StopPerformingEmoteServerRpc()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val = default(ServerRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(1231597065u, val, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendServerRpc(ref val2, 1231597065u, val, (RpcDelivery)0);
				}
				if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
					StopPerformingEmoteClientRpc();
				}
			}
		}

		[ClientRpc]
		private void StopPerformingEmoteClientRpc()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val = default(ClientRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(4042441381u, val, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendClientRpc(ref val2, 4042441381u, val, (RpcDelivery)0);
				}
				if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
					NpcController.Npc.performingEmote = false;
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void ChangeSuitLethalBotServerRpc(ulong idLethalBotController, int suitID, bool playAudio = true)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: 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_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val = default(ServerRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(1430164143u, val, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val2, idLethalBotController);
					BytePacker.WriteValueBitPacked(val2, suitID);
					((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref playAudio, default(ForPrimitives));
					((NetworkBehaviour)this).__endSendServerRpc(ref val2, 1430164143u, val, (RpcDelivery)0);
				}
				if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
					ChangeSuitLethalBotClientRpc(idLethalBotController, suitID, playAudio);
				}
			}
		}

		[ClientRpc]
		private void ChangeSuitLethalBotClientRpc(ulong idLethalBotController, int suitID, bool playAudio = true)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: 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_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val = default(ClientRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(165479150u, val, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val2, idLethalBotController);
					BytePacker.WriteValueBitPacked(val2, suitID);
					((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref playAudio, default(ForPrimitives));
					((NetworkBehaviour)this).__endSendClientRpc(ref val2, 165479150u, val, (RpcDelivery)0);
				}
				if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
					ChangeSuitLethalBot(idLethalBotController, suitID, playAudio);
				}
			}
		}

		public void ChangeSuitLethalBot(ulong idLethalBotController, int suitID, bool playAudio = false)
		{
			if (suitID > StartOfRound.Instance.unlockablesList.unlockables.Count())
			{
				suitID = 0;
			}
			if (LethalBotIdentity.IsSuitOwned(suitID))
			{
				PlayerControllerB val = StartOfRound.Instance.allPlayerScripts[idLethalBotController];
				UnlockableSuit.SwitchSuitForPlayer(val, suitID, playAudio);
				((Renderer)val.thisPlayerModelArms).enabled = false;
				((MonoBehaviour)this).StartCoroutine(Wait2EndOfFrameToRefreshBillBoard());
				LethalBotIdentity.SuitID = suitID;
				Plugin.LogDebug($"Changed suit of lethalBot {NpcController.Npc.playerUsername} to {suitID}: {StartOfRound.Instance.unlockablesList.unlockables[suitID].unlockableName}");
			}
		}

		[IteratorStateMachine(typeof(<Wait2EndOfFrameToRefreshBillBoard>d__326))]
		private IEnumerator Wait2EndOfFrameToRefreshBillBoard()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <Wait2EndOfFrameToRefreshBillBoard>d__326(0)
			{
				<>4__this = this
			};
		}

		[ServerRpc(RequireOwnership = false)]
		public void StartPerformingEmoteLethalBotServerRpc(int emoteID)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val = default(ServerRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(4030498115u, val, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val2, emoteID);
					((NetworkBehaviour)this).__endSendServerRpc(ref val2, 4030498115u, val, (RpcDelivery)0);
				}
				if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
					StartPerformingEmoteLethalBotClientRpc(emoteID);
				}
			}
		}

		[ClientRpc]
		private void StartPerformingEmoteLethalBotClientRpc(int emoteID)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val = default(ClientRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(2252164017u, val, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val2, emoteID);
					((NetworkBehaviour)this).__endSendClientRpc(ref val2, 2252164017u, val, (RpcDelivery)0);
				}
				if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
					NpcController.Npc.performingEmote = true;
					NpcController.Npc.playerBodyAnimator.SetInteger("emoteNumber", emoteID);
				}
			}
		}

		public void PerformTooManyEmoteLethalBotAndSync(int tooManyEmoteID, int playerToSync = -1)
		{
			if (((NetworkBehaviour)this).IsServer)
			{
				PerformTooManyLethalBotClientRpc(tooManyEmoteID, playerToSync);
			}
			else
			{
				PerformTooManyEmoteLethalBotServerRpc(tooManyEmoteID, playerToSync);
			}
		}

		[ServerRpc(RequireOwnership = false)]
		private void PerformTooManyEmoteLethalBotServerRpc(int tooManyEmoteID, int playerToSync = -1)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: 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_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val = default(ServerRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(1133286978u, val, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val2, tooManyEmoteID);
					BytePacker.WriteValueBitPacked(val2, playerToSync);
					((NetworkBehaviour)this).__endSendServerRpc(ref val2, 1133286978u, val, (RpcDelivery)0);
				}
				if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
					PerformTooManyLethalBotClientRpc(tooManyEmoteID, playerToSync);
				}
			}
		}

		[ClientRpc]
		private void PerformTooManyLethalBotClientRpc(int tooManyEmoteID, int playerToSync = -1)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: 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_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val = default(ClientRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(2258798318u, val, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val2, tooManyEmoteID);
					BytePacker.WriteValueBitPacked(val2, playerToSync);
					((NetworkBehaviour)this).__endSendClientRpc(ref val2, 2258798318u, val, (RpcDelivery)0);
				}
				if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
					NpcController.PerformTooManyEmote(tooManyEmoteID, playerToSync);
				}
			}
		}

		public void StopPerformTooManyEmoteLethalBotAndSync()
		{
			if (((NetworkBehaviour)this).IsServer)
			{
				StopPerformTooManyLethalBotClientRpc();
			}
			else
			{
				StopPerformTooManyEmoteLethalBotServerRpc();
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void StopPerformTooManyEmoteLethalBotServerRpc()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val = default(ServerRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(1722031166u, val, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendServerRpc(ref val2, 1722031166u, val, (RpcDelivery)0);
				}
				if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
					StopPerformTooManyLethalBotClientRpc();
				}
			}
		}

		[ClientRpc]
		private void StopPerformTooManyLethalBotClientRpc()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val = default(ClientRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(715298579u, val, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendClientRpc(ref val2, 715298579u, val, (RpcDelivery)0);
				}
				if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
					NpcController.StopPerformingTooManyEmote();
				}
			}
		}

		protected override void __initializeVariables()
		{
			if (FearLevel == null)
			{
				throw new Exception("LethalBotAI.FearLevel cannot be null. All NetworkVariableBase instances must be initialized.");
			}
			((NetworkVariableBase)FearLevel).Initialize((NetworkBehaviour)(object)this);
			((NetworkBehaviour)this).__nameNetworkVariable((NetworkVariableBase)(object)FearLevel, "FearLevel");
			((NetworkBehaviour)this).NetworkVariableFields.Add((NetworkVariableBase)(object)FearLevel);
			if (FearLevelIncreasing == null)
			{
				throw new Exception("LethalBotAI.FearLevelIncreasing cannot be null. All NetworkVariableBase instances must be initialized.");
			}
			((NetworkVariableBase)FearLevelIncreasing).Initialize((NetworkBehaviour)(object)this);
			((NetworkBehaviour)this).__nameNetworkVariable((NetworkVariableBase)(object)FearLevelIncreasing, "FearLevelIncreasing");
			((NetworkBehaviour)this).NetworkVariableFields.Add((NetworkVariableBase)(object)FearLevelIncreasing);
			if (BotInfectionData == null)
			{
				throw new Exception("LethalBotAI.BotInfectionData cannot be null. All NetworkVariableBase instances must be initialized.");
			}
			((NetworkVariableBase)BotInfectionData).Initialize((NetworkBehaviour)(object)this);
			((NetworkBehaviour)this).__nameNetworkVariable((NetworkVariableBase)(object)BotInfectionData, "BotInfectionData");
			((NetworkBehaviour)this).NetworkVariableFields.Add((NetworkVariableBase)(object)BotInfectionData);
			if (HealInfectionLevel == null)
			{
				throw new Exception("LethalBotAI.HealInfectionLevel cannot be null. All NetworkVariableBase instances must be initialized.");
			}
			((NetworkVariableBase)HealInfectionLevel).Initialize((NetworkBehaviour)(object)this);
			((NetworkBehaviour)this).__nameNetworkVariable((NetworkVariableBase)(object)HealInfectionLevel, "HealInfectionLevel");
			((NetworkBehaviour)this).NetworkVariableFields.Add((NetworkVariableBase)(object)HealInfectionLevel);
			((EnemyAI)this).__initializeVariables();
		}

		protected override void __initializeRpcs()
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Expected O, but got Unknown
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Expected O, but got Unknown
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Expected O, but got Unknown
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Expected O, but got Unknown
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Expected O, but got Unknown
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Expected O, but got Unknown
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Expected O, but got Unknown
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Expected O, but got Unknown
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Expected O, but got Unknown
			//IL_0109: Unknown result type (might be due to invalid IL or missing references)
			//IL_0118: Expected O, but got Unknown
			//IL_0125: Unknown result type (might be due to invalid IL or missing references)
			//IL_0134: Expected O, but got Unknown
			//IL_0141: Unknown result type (might be due to invalid IL or missing references)
			//IL_0150: Expected O, but got Unknown
			//IL_015d: Unknown result type (might be due to invalid IL or missing references)
			//IL_016c: Expected O, but got Unknown
			//IL_0179: Unknown result type (might be due to invalid IL or missing references)
			//IL_0188: Expected O, but got Unknown
			//IL_0195: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a4: Expected O, but got Unknown
			//IL_01b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c0: Expected O, but got Unknown
			//IL_01cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dc: Expected O, but got Unknown
			//IL_01e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f8: Expected O, but got Unknown
			//IL_0205: Unknown result type (might be due to invalid IL or missing references)
			//IL_0214: Expected O, but got Unknown
			//IL_0221: Unknown result type (might be due to invalid IL or missing references)
			//IL_0230: Expected O, but got Unknown
			//IL_023d: Unknown result type (might be due to invalid IL or missing references)
			//IL_024c: Expected O, but got Unknown
			//IL_0259: Unknown result type (might be due to invalid IL or missing references)
			//IL_0268: Expected O, but got Unknown
			//IL_0275: Unknown result type (might be due to invalid IL or missing references)
			//IL_0284: Expected O, but got Unknown
			//IL_0291: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a0: Expected O, but got Unknown
			//IL_02ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bc: Expected O, but got Unknown
			//IL_02c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d8: Expected O, but got Unknown
			//IL_02e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f4: Expected O, but got Unknown
			//IL_0301: Unknown result type (might be due to invalid IL or missing references)
			//IL_0310: Expected O, but got Unknown
			//IL_031d: Unknown result type (might be due to invalid IL or missing references)
			//IL_032c: Expected O, but got Unknown
			//IL_0339: Unknown result type (might be due to invalid IL or missing references)
			//IL_0348: Expected O, but got Unknown
			//IL_0355: Unknown result type (might be due to invalid IL or missing references)
			//IL_0364: Expected O, but got Unknown
			//IL_0371: Unknown result type (might be due to invalid IL or missing references)
			//IL_0380: Expected O, but got Unknown
			//IL_038d: Unknown result type (might be due to invalid IL or missing references)
			//IL_039c: Expected O, but got Unknown
			//IL_03a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b8: Expected O, but got Unknown
			//IL_03c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d4: Expected O, but got Unknown
			//IL_03e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f0: Expected O, but got Unknown
			//IL_03fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_040c: Expected O, but got Unknown
			//IL_0419: Unknown result type (might be due to invalid IL or missing references)
			//IL_0428: Expected O, but got Unknown
			//IL_0435: Unknown result type (might be due to invalid IL or missing references)
			//IL_0444: Expected O, but got Unknown
			//IL_0451: Unknown result type (might be due to invalid IL or missing references)
			//IL_0460: Expected O, but got Unknown
			//IL_046d: Unknown result type (might be due to invalid IL or missing references)
			//IL_047c: Expected O, but got Unknown
			//IL_0489: Unknown result type (might be due to invalid IL or missing references)
			//IL_0498: Expected O, but got Unknown
			//IL_04a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_04b4: Expected O, but got Unknown
			//IL_04c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_04d0: Expected O, but got Unknown
			//IL_04dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ec: Expected O, but got Unknown
			//IL_04f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0508: Expected O, but got Unknown
			//IL_0515: Unknown result type (might be due to invalid IL or missing references)
			//IL_0524: Expected O, but got Unknown
			//IL_0531: Unknown result type (might be due to invalid IL or missing references)
			//IL_0540: Expected O, but got Unknown
			//IL_054d: Unknown result type (might be due to invalid IL or missing references)
			//IL_055c: Expected O, but got Unknown
			//IL_0569: Unknown result type (might be due to invalid IL or missing references)
			//IL_0578: Expected O, but got Unknown
			//IL_0585: Unknown result type (might be due to invalid IL or missing references)
			//IL_0594: Expected O, but got Unknown
			((NetworkBehaviour)this).__registerRpc(2943335133u, new RpcReceiveHandler(__rpc_handler_2943335133), "ChangeOwnershipOfBotInventoryServerRpc");
			((NetworkBehaviour)this).__registerRpc(177443032u, new RpcReceiveHandler(__rpc_handler_177443032), "ChangeNpcOwnershipOfBotServerRpc");
			((NetworkBehaviour)this).__registerRpc(1460449774u, new RpcReceiveHandler(__rpc_handler_1460449774), "ChangeOwnershipOfLethalPhoneServerRpc");
			((NetworkBehaviour)this).__registerRpc(2347806360u, new RpcReceiveHandler(__rpc_handler_2347806360), "PlayAudioServerRpc");
			((NetworkBehaviour)this).__registerRpc(3845412175u, new RpcReceiveHandler(__rpc_handler_3845412175), "PlayAudioClientRpc");
			((NetworkBehaviour)this).__registerRpc(3126638350u, new RpcReceiveHandler(__rpc_handler_3126638350), "TeleportLethalBotServerRpc");
			((NetworkBehaviour)this).__registerRpc(1974751311u, new RpcReceiveHandler(__rpc_handler_1974751311), "TeleportLethalBotClientRpc");
			((NetworkBehaviour)this).__registerRpc(80187027u, new RpcReceiveHandler(__rpc_handler_80187027), "TeleportLethalBotVehicleServerRpc");
			((NetworkBehaviour)this).__registerRpc(2828257530u, new RpcReceiveHandler(__rpc_handler_2828257530), "TeleportLethalBotVehicleClientRpc");
			((NetworkBehaviour)this).__registerRpc(1452686656u, new RpcReceiveHandler(__rpc_handler_1452686656), "SyncAssignTargetAndSetMovingToServerRpc");
			((NetworkBehaviour)this).__registerRpc(1231162204u, new RpcReceiveHandler(__rpc_handler_1231162204), "SyncFromAssignTargetAndSetMovingToClientRpc");
			((NetworkBehaviour)this).__registerRpc(3832073478u, new RpcReceiveHandler(__rpc_handler_3832073478), "UpdateLethalBotPositionServerRpc");
			((NetworkBehaviour)this).__registerRpc(188845853u, new RpcReceiveHandler(__rpc_handler_188845853), "UpdateLethalBotPositionClientRpc");
			((NetworkBehaviour)this).__registerRpc(1296515749u, new RpcReceiveHandler(__rpc_handler_1296515749), "UpdatelLethalBotRotationAndLookServerRpc");
			((NetworkBehaviour)this).__registerRpc(858392864u, new RpcReceiveHandler(__rpc_handler_858392864), "UpdateLethalBotRotationAndLookClientRpc");
			((NetworkBehaviour)this).__registerRpc(1568272076u, new RpcReceiveHandler(__rpc_handler_1568272076), "UpdateLethalBotAnimationServerRpc");
			((NetworkBehaviour)this).__registerRpc(3685310123u, new RpcReceiveHandler(__rpc_handler_3685310123), "UpdateLethalBotAnimationClientRpc");
			((NetworkBehaviour)this).__registerRpc(3490817090u, new RpcReceiveHandler(__rpc_handler_3490817090), "UpdateLethalBotSpecialAnimationServerRpc");
			((NetworkBehaviour)this).__registerRpc(1849617960u, new RpcReceiveHandler(__rpc_handler_1849617960), "UpdateLethalBotSpecialAnimationClientRpc");
			((NetworkBehaviour)this).__registerRpc(526852516u, new RpcReceiveHandler(__rpc_handler_526852516), "SyncSetFaceUnderwaterServerRpc");
			((NetworkBehaviour)this).__registerRpc(1320910236u, new RpcReceiveHandler(__rpc_handler_1320910236), "SyncSetFaceUnderwaterClientRpc");
			((NetworkBehaviour)this).__registerRpc(1649434889u, new RpcReceiveHandler(__rpc_handler_1649434889), "GrabItemServerRpc");
			((NetworkBehaviour)this).__registerRpc(2115356580u, new RpcReceiveHandler(__rpc_handler_2115356580), "GrabItemClientRpc");
			((NetworkBehaviour)this).__registerRpc(505760048u, new RpcReceiveHandler(__rpc_handler_505760048), "SwitchItemSlotsServerRpc");
			((NetworkBehaviour)this).__registerRpc(4160081252u, new RpcReceiveHandler(__rpc_handler_4160081252), "SwitchItemSlotsClientRpc");
			((NetworkBehaviour)this).__registerRpc(3560000878u, new RpcReceiveHandler(__rpc_handler_3560000878), "DespawnHeldObjectOnServerRpc");
			((NetworkBehaviour)this).__registerRpc(2810675767u, new RpcReceiveHandler(__rpc_handler_2810675767), "DespawnHeldObjectClientRpc");
			((NetworkBehaviour)this).__registerRpc(1636365880u, new RpcReceiveHandler(__rpc_handler_1636365880), "SetObjectAsNoLongerHeldServerRpc");
			((NetworkBehaviour)this).__registerRpc(1141501747u, new RpcReceiveHandler(__rpc_handler_1141501747), "SetObjectAsNoLongerHeldClientRpc");
			((NetworkBehaviour)this).__registerRpc(3223226838u, new RpcReceiveHandler(__rpc_handler_3223226838), "PlaceGrabbableObjectServerRpc");
			((NetworkBehaviour)this).__registerRpc(2538662570u, new RpcReceiveHandler(__rpc_handler_2538662570), "PlaceGrabbableObjectClientRpc");
			((NetworkBehaviour)this).__registerRpc(2156721580u, new RpcReceiveHandler(__rpc_handler_2156721580), "SyncBatteryLethalBotServerRpc");
			((NetworkBehaviour)this).__registerRpc(2145730745u, new RpcReceiveHandler(__rpc_handler_2145730745), "SyncBatteryLethalBotClientRpc");
			((NetworkBehaviour)this).__registerRpc(2881373730u, new RpcReceiveHandler(__rpc_handler_2881373730), "JumpServerRpc");
			((NetworkBehaviour)this).__registerRpc(1406234559u, new RpcReceiveHandler(__rpc_handler_1406234559), "JumpClientRpc");
			((NetworkBehaviour)this).__registerRpc(3640508774u, new RpcReceiveHandler(__rpc_handler_3640508774), "JumpLandFromServerRpc");
			((NetworkBehaviour)this).__registerRpc(2079473104u, new RpcReceiveHandler(__rpc_handler_2079473104), "JumpLandFromClientRpc");
			((NetworkBehaviour)this).__registerRpc(1619705390u, new RpcReceiveHandler(__rpc_handler_1619705390), "ChangeSinkingStateServerRpc");
			((NetworkBehaviour)this).__registerRpc(3427657121u, new RpcReceiveHandler(__rpc_handler_3427657121), "ChangeSinkingStateClientRpc");
			((NetworkBehaviour)this).__registerRpc(71921022u, new RpcReceiveHandler(__rpc_handler_71921022), "DisableJetpackModeServerRpc");
			((NetworkBehaviour)this).__registerRpc(4175123208u, new RpcReceiveHandler(__rpc_handler_4175123208), "DisableJetpackModeClientRpc");
			((NetworkBehaviour)this).__registerRpc(1231597065u, new RpcReceiveHandler(__rpc_handler_1231597065), "StopPerformingEmoteServerRpc");
			((NetworkBehaviour)this).__registerRpc(4042441381u, new RpcReceiveHandler(__rpc_handler_4042441381), "StopPerformingEmoteClientRpc");
			((NetworkBehaviour)this).__registerRpc(1430164143u, new RpcReceiveHandler(__rpc_handler_1430164143), "ChangeSuitLethalBotServerRpc");
			((NetworkBehaviour)this).__registerRpc(165479150u, new RpcReceiveHandler(__rpc_handler_165479150), "ChangeSuitLethalBotClientRpc");
			((NetworkBehaviour)this).__registerRpc(4030498115u, new RpcReceiveHandler(__rpc_handler_4030498115), "StartPerformingEmoteLethalBotServerRpc");
			((NetworkBehaviour)this).__registerRpc(2252164017u, new RpcReceiveHandler(__rpc_handler_2252164017), "StartPerformingEmoteLethalBotClientRpc");
			((NetworkBehaviour)this).__registerRpc(1133286978u, new RpcReceiveHandler(__rpc_handler_1133286978), "PerformTooManyEmoteLethalBotServerRpc");
			((NetworkBehaviour)this).__registerRpc(2258798318u, new RpcReceiveHandler(__rpc_handler_2258798318), "PerformTooManyLethalBotClientRpc");
			((NetworkBehaviour)this).__registerRpc(1722031166u, new RpcReceiveHandler(__rpc_handler_1722031166), "StopPerformTooManyEmoteLethalBotServerRpc");
			((NetworkBehaviour)this).__registerRpc(715298579u, new RpcReceiveHandler(__rpc_handler_715298579), "StopPerformTooManyLethalBotClientRpc");
			((EnemyAI)this).__initializeRpcs();
		}

		private static void __rpc_handler_2943335133(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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_0050: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				ulong newOwnerClientId = default(ulong);
				ByteUnpacker.ReadValueBitPacked(reader, ref newOwnerClientId);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((LethalBotAI)(object)target).ChangeOwnershipOfBotInventoryServerRpc(newOwnerClientId);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_177443032(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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_0050: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				ulong newOwnerClientId = default(ulong);
				ByteUnpacker.ReadValueBitPacked(reader, ref newOwnerClientId);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((LethalBotAI)(object)target).ChangeNpcOwnershipOfBotServerRpc(newOwnerClientId);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1460449774(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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_0050: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				ulong newOwnerClientId = default(ulong);
				ByteUnpacker.ReadValueBitPacked(reader, ref newOwnerClientId);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((LethalBotAI)(object)target).ChangeOwnershipOfLethalPhoneServerRpc(newOwnerClientId);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2347806360(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				bool flag = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
				string smallPathAudioClip = null;
				if (flag)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe(ref smallPathAudioClip, false);
				}
				int enumTalkativeness = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref enumTalkativeness);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((LethalBotAI)(object)target).PlayAudioServerRpc(smallPathAudioClip, enumTalkativeness);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3845412175(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				bool flag = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
				string smallPathAudioClip = null;
				if (flag)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe(ref smallPathAudioClip, false);
				}
				int enumTalkativeness = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref enumTalkativeness);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((LethalBotAI)(object)target).PlayAudioClientRpc(smallPathAudioClip, enumTalkativeness);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3126638350(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//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_007c: 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_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Invalid comparison between Unknown and I4
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if (rpcParams.Server.Receive.SenderClientId != target.OwnerClientId)
			{
				if ((int)networkManager.LogLevel <= 1)
				{
					Debug.LogError((object)"Only the owner can invoke a ServerRpc that requires ownership!");
				}
			}
			else
			{
				TeleportLethalBotNetworkSerializable teleportData = default(TeleportLethalBotNetworkSerializable);
				((FastBufferReader)(ref reader)).ReadValueSafe<TeleportLethalBotNetworkSerializable>(ref teleportData, default(ForNetworkSerializable));
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((LethalBotAI)(object)target).TeleportLethalBotServerRpc(teleportData);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1974751311(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				TeleportLethalBotNetworkSerializable teleportLethalBotNetworkSerializable = default(TeleportLethalBotNetworkSerializable);
				((FastBufferReader)(ref reader)).ReadValueSafe<TeleportLethalBotNetworkSerializable>(ref teleportLethalBotNetworkSerializable, default(ForNetworkSerializable));
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((LethalBotAI)(object)target).TeleportLethalBotClientRpc(teleportLethalBotNetworkSerializable);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_80187027(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//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_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Invalid comparison between Unknown and I4
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if (rpcParams.Server.Receive.SenderClientId != target.OwnerClientId)
			{
				if ((int)networkManager.LogLevel <= 1)
				{
					Debug.LogError((object)"Only the owner can invoke a ServerRpc that requires ownership!");
				}
				return;
			}
			Vector3 pos = default(Vector3);
			((FastBufferReader)(ref reader)).ReadValueSafe(ref pos);
			bool enteringVehicle = default(bool);
			((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref enteringVehicle, default(ForPrimitives));
			NetworkBehaviourReference networkBehaviourReferenceVehicle = default(NetworkBehaviourReference);
			((FastBufferReader)(ref reader)).ReadValueSafe<NetworkBehaviourReference>(ref networkBehaviourReferenceVehicle, default(ForNetworkSerializable));
			target.__rpc_exec_stage = (__RpcExecStage)1;
			((LethalBotAI)(object)target).TeleportLethalBotVehicleServerRpc(pos, enteringVehicle, networkBehaviourReferenceVehicle);
			target.__rpc_exec_stage = (__RpcExecStage)0;
		}

		private static void __rpc_handler_2828257530(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				Vector3 pos = default(Vector3);
				((FastBufferReader)(ref reader)).ReadValueSafe(ref pos);
				bool enteringVehicle = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref enteringVehicle, default(ForPrimitives));
				NetworkBehaviourReference networkBehaviourReferenceVehicle = default(NetworkBehaviourReference);
				((FastBufferReader)(ref reader)).ReadValueSafe<NetworkBehaviourReference>(ref networkBehaviourReferenceVehicle, default(ForNetworkSerializable));
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((LethalBotAI)(object)target).TeleportLethalBotVehicleClientRpc(pos, enteringVehicle, networkBehaviourReferenceVehicle);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1452686656(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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_0050: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				ulong playerid = default(ulong);
				ByteUnpacker.ReadValueBitPacked(reader, ref playerid);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((LethalBotAI)(object)target).SyncAssignTargetAndSetMovingToServerRpc(playerid);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1231162204(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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_0050: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				ulong playerid = default(ulong);
				ByteUnpacker.ReadValueBitPacked(reader, ref playerid);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((LethalBotAI)(object)target).SyncFromAssignTargetAndSetMovingToClientRpc(playerid);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3832073478(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				Vector3 newPos = default(Vector3);
				((FastBufferReader)(ref reader)).ReadValueSafe(ref newPos);
				bool inElevator = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref inElevator, default(ForPrimitives));
				bool inShipRoom = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref inShipRoom, default(ForPrimitives));
				bool exhausted = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref exhausted, default(ForPrimitives));
				bool isPlayerGrounded = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref isPlayerGrounded, default(ForPrimitives));
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((LethalBotAI)(object)target).UpdateLethalBotPositionServerRpc(newPos, inElevator, inShipRoom, exhausted, isPlayerGrounded);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_188845853(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				Vector3 newPos = default(Vector3);
				((FastBufferReader)(ref reader)).ReadValueSafe(ref newPos);
				bool inElevator = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref inElevator, default(ForPrimitives));
				bool isInShip = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref isInShip, default(ForPrimitives));
				bool exhausted = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref exhausted, default(ForPrimitives));
				bool isPlayerGrounded = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref isPlayerGrounded, default(ForPrimitives));
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((LethalBotAI)(object)target).UpdateLethalBotPositionClientRpc(newPos, inElevator, isInShip, exhausted, isPlayerGrounded);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1296515749(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				bool flag = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
				string stateIndicator = null;
				if (flag)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe(ref stateIndicator, false);
				}
				bool flag2 = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag2, default(ForPrimitives));
				LookAtTarget lookAtTarget = null;
				if (flag2)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe<LookAtTarget>(ref lookAtTarget, default(ForNetworkSerializable));
				}
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((LethalBotAI)(object)target).UpdatelLethalBotRotationAndLookServerRpc(stateIndicator, lookAtTarget);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_858392864(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				bool flag = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
				string stateIndicator = null;
				if (flag)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe(ref stateIndicator, false);
				}
				bool flag2 = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag2, default(ForPrimitives));
				LookAtTarget lookAtTarget = null;
				if (flag2)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe<LookAtTarget>(ref lookAtTarget, default(ForNetworkSerializable));
				}
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((LethalBotAI)(object)target).UpdateLethalBotRotationAndLookClientRpc(stateIndicator, lookAtTarget);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1568272076(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int animationState = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref animationState);
				float animationSpeed = default(float);
				((FastBufferReader)(ref reader)).ReadValueSafe<float>(ref animationSpeed, default(ForPrimitives));
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((LethalBotAI)(object)target).UpdateLethalBotAnimationServerRpc(animationState, animationSpeed);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3685310123(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int animationState = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref animationState);
				float animationSpeed = default(float);
				((FastBufferReader)(ref reader)).ReadValueSafe<float>(ref animationSpeed, default(ForPrimitives));
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((LethalBotAI)(object)target).UpdateLethalBotAnimationClientRpc(animationState, animationSpeed);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3490817090(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				bool specialAnimation = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref specialAnimation, default(ForPrimitives));
				float timed = default(float);
				((FastBufferReader)(ref reader)).ReadValueSafe<float>(ref timed, default(ForPrimitives));
				bool climbingLadder = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref climbingLadder, default(ForPrimitives));
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((LethalBotAI)(object)target).UpdateLethalBotSpecialAnimationServerRpc(specialAnimation, timed, climbingLadder);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1849617960(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				bool specialAnimation = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref specialAnimation, default(ForPrimitives));
				float timed = default(float);
				((FastBufferReader)(ref reader)).ReadValueSafe<float>(ref timed, default(ForPrimitives));
				bool climbingLadder = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref climbingLadder, default(ForPrimitives));
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((LethalBotAI)(object)target).UpdateLethalBotSpecialAnimationClientRpc(specialAnimation, timed, climbingLadder);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_526852516(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				bool isUnderwater = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref isUnderwater, default(ForPrimitives));
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((LethalBotAI)(object)target).SyncSetFaceUnderwaterServerRpc(isUnderwater);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1320910236(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				bool isUnderwater = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref isUnderwater, default(ForPrimitives));
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((LethalBotAI)(object)target).SyncSetFaceUnderwaterClientRpc(isUnderwater);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1649434889(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				NetworkObjectReference networkObjectReference = default(NetworkObjectReference);
				((FastBufferReader)(ref reader)).ReadValueSafe<NetworkObjectReference>(ref networkObjectReference, default(ForNetworkSerializable));
				bool itemGiven = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref itemGiven, default(ForPrimitives));
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((LethalBotAI)(object)target).GrabItemServerRpc(networkObjectReference, itemGiven);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2115356580(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				NetworkObjectReference networkObjectReference = default(NetworkObjectReference);
				((FastBufferReader)(ref reader)).ReadValueSafe<NetworkObjectReference>(ref networkObjectReference, default(ForNetworkSerializable));
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((LethalBotAI)(object)target).GrabItemClientRpc(networkObjectReference);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_505760048(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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_0050: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int slotNum = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref slotNum);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((LethalBotAI)(object)target).SwitchItemSlotsServerRpc(slotNum);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_4160081252(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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_0050: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int slotNum = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref slotNum);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((LethalBotAI)(object)target).SwitchItemSlotsClientRpc(slotNum);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3560000878(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//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_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Invalid comparison between Unknown and I4
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if (rpcParams.Server.Receive.SenderClientId != target.OwnerClientId)
			{
				if ((int)networkManager.LogLevel <= 1)
				{
					Debug.LogError((object)"Only the owner can invoke a ServerRpc that requires ownership!");
				}
			}
			else
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((LethalBotAI)(object)target).DespawnHeldObjectOnServerRpc();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2810675767(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((LethalBotAI)(object)target).DespawnHeldObjectClientRpc();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1636365880(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				DropItemNetworkSerializable objectAsNoLongerHeldServerRpc = default(DropItemNetworkSerializable);
				((FastBufferReader)(ref reader)).ReadValueSafe<DropItemNetworkSerializable>(ref objectAsNoLongerHeldServerRpc, default(ForNetworkSerializable));
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((LethalBotAI)(object)target).SetObjectAsNoLongerHeldServerRpc(objectAsNoLongerHeldServerRpc);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1141501747(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				DropItemNetworkSerializable objectAsNoLongerHeldClientRpc = default(DropItemNetworkSerializable);
				((FastBufferReader)(ref reader)).ReadValueSafe<DropItemNetworkSerializable>(ref objectAsNoLongerHeldClientRpc, default(ForNetworkSerializable));
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((LethalBotAI)(object)target).SetObjectAsNoLongerHeldClientRpc(objectAsNoLongerHeldClientRpc);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3223226838(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				PlaceItemNetworkSerializable placeItemNetworkSerializable = default(PlaceItemNetworkSerializable);
				((FastBufferReader)(ref reader)).ReadValueSafe<PlaceItemNetworkSerializable>(ref placeItemNetworkSerializable, default(ForNetworkSerializable));
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((LethalBotAI)(object)target).PlaceGrabbableObjectServerRpc(placeItemNetworkSerializable);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2538662570(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				PlaceItemNetworkSerializable placeItemNetworkSerializable = default(PlaceItemNetworkSerializable);
				((FastBufferReader)(ref reader)).ReadValueSafe<PlaceItemNetworkSerializable>(ref placeItemNetworkSerializable, default(ForNetworkSerializable));
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((LethalBotAI)(object)target).PlaceGrabbableObjectClientRpc(placeItemNetworkSerializable);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2156721580(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				NetworkObjectReference networkObjectReferenceGrabbableObject = default(NetworkObjectReference);
				((FastBufferReader)(ref reader)).ReadValueSafe<NetworkObjectReference>(ref networkObjectReferenceGrabbableObject, default(ForNetworkSerializable));
				int charge = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref charge);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((LethalBotAI)(object)target).SyncBatteryLethalBotServerRpc(networkObjectReferenceGrabbableObject, charge);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2145730745(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				NetworkObjectReference networkObjectReferenceGrabbableObject = default(NetworkObjectReference);
				((FastBufferReader)(ref reader)).ReadValueSafe<NetworkObjectReference>(ref networkObjectReferenceGrabbableObject, default(ForNetworkSerializable));
				int charge = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref charge);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((LethalBotAI)(object)target).SyncBatteryLethalBotClientRpc(networkObjectReferenceGrabbableObject, charge);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2881373730(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((LethalBotAI)(object)target).JumpServerRpc();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1406234559(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((LethalBotAI)(object)target).JumpClientRpc();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3640508774(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				bool fallHard = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref fallHard, default(ForPrimitives));
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((LethalBotAI)(object)target).JumpLandFromServerRpc(fallHard);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2079473104(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				bool fallHard = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref fallHard, default(ForPrimitives));
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((LethalBotAI)(object)target).JumpLandFromClientRpc(fallHard);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1619705390(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//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_007c: 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_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Invalid comparison between Unknown and I4
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if (rpcParams.Server.Receive.SenderClientId != target.OwnerClientId)
			{
				if ((int)networkManager.LogLevel <= 1)
				{
					Debug.LogError((object)"Only the owner can invoke a ServerRpc that requires ownership!");
				}
				return;
			}
			bool startSinking = default(bool);
			((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref startSinking, default(ForPrimitives));
			float sinkingSpeed = default(float);
			((FastBufferReader)(ref reader)).ReadValueSafe<float>(ref sinkingSpeed, default(ForPrimitives));
			int audioClipIndex = default(int);
			ByteUnpacker.ReadValueBitPacked(reader, ref audioClipIndex);
			target.__rpc_exec_stage = (__RpcExecStage)1;
			((LethalBotAI)(object)target).ChangeSinkingStateServerRpc(startSinking, sinkingSpeed, audioClipIndex);
			target.__rpc_exec_stage = (__RpcExecStage)0;
		}

		private static void __rpc_handler_3427657121(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				bool startSinking = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref startSinking, default(ForPrimitives));
				float sinkingSpeed = default(float);
				((FastBufferReader)(ref reader)).ReadValueSafe<float>(ref sinkingSpeed, default(ForPrimitives));
				int audioClipIndex = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref audioClipIndex);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((LethalBotAI)(object)target).ChangeSinkingStateClientRpc(startSinking, sinkingSpeed, audioClipIndex);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_71921022(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//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_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Invalid comparison between Unknown and I4
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if (rpcParams.Server.Receive.SenderClientId != target.OwnerClientId)
			{
				if ((int)networkManager.LogLevel <= 1)
				{
					Debug.LogError((object)"Only the owner can invoke a ServerRpc that requires ownership!");
				}
			}
			else
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((LethalBotAI)(object)target).DisableJetpackModeServerRpc();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_4175123208(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((LethalBotAI)(object)target).DisableJetpackModeClientRpc();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1231597065(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((LethalBotAI)(object)target).StopPerformingEmoteServerRpc();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_4042441381(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((LethalBotAI)(object)target).StopPerformingEmoteClientRpc();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1430164143(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				ulong idLethalBotController = default(ulong);
				ByteUnpacker.ReadValueBitPacked(reader, ref idLethalBotController);
				int suitID = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref suitID);
				bool playAudio = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref playAudio, default(ForPrimitives));
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((LethalBotAI)(object)target).ChangeSuitLethalBotServerRpc(idLethalBotController, suitID, playAudio);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_165479150(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				ulong idLethalBotController = default(ulong);
				ByteUnpacker.ReadValueBitPacked(reader, ref idLethalBotController);
				int suitID = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref suitID);
				bool playAudio = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref playAudio, default(ForPrimitives));
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((LethalBotAI)(object)target).ChangeSuitLethalBotClientRpc(idLethalBotController, suitID, playAudio);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_4030498115(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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_0050: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int emoteID = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref emoteID);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((LethalBotAI)(object)target).StartPerformingEmoteLethalBotServerRpc(emoteID);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2252164017(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: 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_0050: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int emoteID = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref emoteID);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((LethalBotAI)(object)target).StartPerformingEmoteLethalBotClientRpc(emoteID);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1133286978(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int tooManyEmoteID = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref tooManyEmoteID);
				int playerToSync = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref playerToSync);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((LethalBotAI)(object)target).PerformTooManyEmoteLethalBotServerRpc(tooManyEmoteID, playerToSync);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2258798318(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int tooManyEmoteID = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref tooManyEmoteID);
				int playerToSync = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref playerToSync);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((LethalBotAI)(object)target).PerformTooManyLethalBotClientRpc(tooManyEmoteID, playerToSync);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1722031166(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((LethalBotAI)(object)target).StopPerformTooManyEmoteLethalBotServerRpc();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_715298579(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((LethalBotAI)(object)target).StopPerformTooManyLethalBotClientRpc();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		protected internal override string __getTypeName()
		{
			return "LethalBotAI";
		}
	}
	public class TimedTouchingGroundCheck
	{
		private bool isTouchingGround = true;

		private RaycastHit groundHit;

		private long timer = 2000000L;

		private long lastTimeCalculate;

		public bool IsTouchingGround(Vector3 lethalBotPosition)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			if (!NeedToRecalculate())
			{
				return isTouchingGround;
			}
			CalculateTouchingGround(lethalBotPosition);
			return isTouchingGround;
		}

		public RaycastHit GetGroundHit(Vector3 lethalBotPosition)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			if (!NeedToRecalculate())
			{
				return groundHit;
			}
			CalculateTouchingGround(lethalBotPosition);
			return groundHit;
		}

		public void ForceRecalculationNextThink(bool invalidateIsTouchingGround = false)
		{
			if (invalidateIsTouchingGround)
			{
				isTouchingGround = false;
				lastTimeCalculate = DateTime.Now.Ticks;
			}
			else
			{
				lastTimeCalculate = 0L;
			}
		}

		private bool NeedToRecalculate()
		{
			long num = DateTime.Now.Ticks - lastTimeCalculate;
			if (num > timer)
			{
				lastTimeCalculate = DateTime.Now.Ticks;
				return true;
			}
			return false;
		}

		private void CalculateTouchingGround(Vector3 lethalBotPosition)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			isTouchingGround = Physics.Raycast(new Ray(lethalBotPosition + Vector3.up, Vector3.down), ref groundHit, 2.5f, StartOfRound.Instance.walkableSurfacesMask, (QueryTriggerInteraction)1);
		}
	}
	public class LethalBotFearQuery
	{
		public EnemyAI? Bot { get; private set; }

		public EnemyAI EnemyAI { get; private set; }

		public PlayerControllerB? PlayerToCheck { get; private set; }

		public EnumFearQueryType QueryType { get; private set; }

		public LethalBotFearQuery(EnemyAI? bot, EnemyAI enemyAI, PlayerControllerB? playerToCheck, EnumFearQueryType queryType)
			: this(bot, enemyAI, queryType)
		{
			PlayerToCheck = playerToCheck;
		}

		public LethalBotFearQuery(EnemyAI? bot, EnemyAI enemyAI, EnumFearQueryType queryType)
		{
			Bot = bot;
			EnemyAI = enemyAI;
			QueryType = queryType;
		}
	}
	public class LethalBotIdentity
	{
		public int IdIdentity { get; }

		public string Name { get; set; }

		public int? SuitID { get; set; }

		public LethalBotVoice Voice { get; set; }

		public LethalBotLoadout Loadout { get; set; }

		public string MoreCompanyCosmetics { get; set; }

		public int GroupID { get; set; }

		public DeadBodyInfo? DeadBody { get; set; }

		public object? BodyReplacementBase { get; set; }

		public int HpMax { get; set; }

		public int Hp { get; set; }

		public bool DiedLastRound { get; set; }

		public bool JustJoinedServer { get; set; }

		public int? XP { get; set; }

		public int Level { get; set; }

		public EnumStatusIdentity Status { get; set; }

		public EnumDefaultAIState DefaultAIState { get; set; }

		public bool Alive
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				return Hp > 0;
			}
		}

		public string Suit
		{
			get
			{
				if (!SuitID.HasValue)
				{
					return "";
				}
				string arg = ((SuitID.Value > StartOfRound.Instance.unlockablesList.unlockables.Count()) ? "Not found" : StartOfRound.Instance.unlockablesList.unlockables[SuitID.Value].unlockableName);
				return $"{SuitID.Value}: {arg}";
			}
		}

		public LethalBotIdentity(int idIdentity, string name, int? suitID, LethalBotVoice voice, LethalBotLoadout loadout, string moreCompanyCosmetics, int groupID, EnumDefaultAIState defaultAIState = EnumDefaultAIState.FollowPlayer, int? Xp = null)
		{
			IdIdentity = idIdentity;
			Name = name;
			SuitID = suitID;
			Voice = voice;
			Loadout = loadout;
			MoreCompanyCosmetics = moreCompanyCosmetics;
			GroupID = groupID;
			HpMax = 100;
			Hp = HpMax;
			DiedLastRound = true;
			JustJoinedServer = true;
			XP = Xp;
			Status = EnumStatusIdentity.Available;
			DefaultAIState = defaultAIState;
		}

		public void UpdateIdentity(int Hp, int? suitID, int? Xp, int level, EnumStatusIdentity enumStatusIdentity)
		{
			this.Hp = Hp;
			SuitID = suitID;
			XP = Xp;
			Level = level;
			Status = enumStatusIdentity;
		}

		public override string ToString()
		{
			return $"IdIdentity: {IdIdentity}, name: {Name}, suit {Suit}, Hp {Hp}/{HpMax}, XP {XP}, Level {Level}, More Company Cosmetics {MoreCompanyCosmetics}, Internal Group ID {GroupID}, Status {(int)Status} '{Status}', Voice : {{{Voice.ToString()}}}, Loadout : {{{Loadout.ToString()}}}";
		}

		public int GetRandomSuitID()
		{
			StartOfRound instance = StartOfRound.Instance;
			List<int> list = new List<int>();
			foreach (KeyValuePair<int, GameObject> spawnedShipUnlockable in instance.SpawnedShipUnlockables)
			{
				if (!((Object)(object)spawnedShipUnlockable.Value == (Object)null))
				{
					UnlockableItem val = instance.unlockablesList.unlockables[spawnedShipUnlockable.Key];
					if (val != null && val.unlockableType == 0)
					{
						list.Add(spawnedShipUnlockable.Key);
					}
				}
			}
			if (list.Count == 0)
			{
				return 0;
			}
			Random random = new Random();
			int num = random.Next(0, list.Count);
			if (num >= list.Count)
			{
				return 0;
			}
			return list[num];
		}

		public bool IsSuitOwned(int suitID)
		{
			UnlockableItem val = StartOfRound.Instance.unlockablesList.unlockables[suitID];
			if (!val.hasBeenUnlockedByPlayer && !val.alreadyUnlocked && (!StartOfRound.Instance.isChallengeFile || !val.unlockedInChallengeFile) && (!StartOfRound.Instance.SpawnedShipUnlockables.TryGetValue(suitID, out var value) || (Object)(object)value == (Object)null))
			{
				return false;
			}
			return true;
		}
	}
	public class LethalBotLoadout
	{
		private HashSet<string> _itemNames;

		public int IdLoadout { get; }

		public string Name { get; }

		public Item[] Items { get; set; }

		public LethalBotLoadout(int idLoadout, string name, Item[] items)
		{
			IdLoadout = idLoadout;
			Name = name;
			Items = items;
			RebuildCache();
		}

		public void RebuildCache()
		{
			_itemNames = (from i in Items
				where (Object)(object)i != (Object)null
				select i.itemName).ToHashSet();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public bool IsGrabbableObjectInLoadout([NotNullWhen(true)] GrabbableObject grabbableObject)
		{
			if ((Object)(object)grabbableObject != (Object)null)
			{
				return _itemNames.Contains(grabbableObject.itemProperties.itemName);
			}
			return false;
		}

		public override string ToString()
		{
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.AppendLine($"IdLoadout: {IdLoadout}, Name: {Name}");
			stringBuilder.AppendLine("Items:");
			if (Items.Length == 0)
			{
				stringBuilder.AppendLine("(None)");
			}
			else
			{
				Item[] items = Items;
				foreach (Item val in items)
				{
					if ((Object)(object)val == (Object)null)
					{
						stringBuilder.AppendLine("(null Item)");
					}
					else
					{
						stringBuilder.AppendLine($"Name: {val.itemName} with ID: {val.itemId}");
					}
				}
			}
			return stringBuilder.ToString();
		}
	}
	public class LethalBotSearchRoutine
	{
		[CompilerGenerated]
		private sealed class <SearchCoroutine>d__28 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public LethalBotSearchRoutine <>4__this;

			private float <proximitySqr>5__2;

			private float <nextValidCheck>5__3;

			private float <lowestPathDistance>5__4;

			private int <stuckChecks>5__5;

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

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

			[DebuggerHidden]
			public <SearchCoroutine>d__28(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0077: Unknown result type (might be due to invalid IL or missing references)
				//IL_01d2: Unknown result type (might be due to invalid IL or missing references)
				//IL_01e2: Unknown result type (might be due to invalid IL or missing references)
				//IL_01e7: Unknown result type (might be due to invalid IL or missing references)
				//IL_01ec: Unknown result type (might be due to invalid IL or missing references)
				//IL_0255: Unknown result type (might be due to invalid IL or missing references)
				int num = <>1__state;
				LethalBotSearchRoutine CS$<>8__locals0 = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					CS$<>8__locals0.searchInProgress = true;
					<>2__current = null;
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					goto IL_0368;
				case 2:
					<>1__state = -1;
					if (!CS$<>8__locals0.isSelectingTarget)
					{
						CS$<>8__locals0.selectTargetCoroutine = ((MonoBehaviour)CS$<>8__locals0.ai).StartCoroutine(CS$<>8__locals0.SelectTargetCoroutine());
					}
					goto IL_00f0;
				case 3:
					<>1__state = -1;
					goto IL_00f0;
				case 4:
					<>1__state = -1;
					CS$<>8__locals0.selectTargetCoroutine = ((MonoBehaviour)CS$<>8__locals0.ai).StartCoroutine(CS$<>8__locals0.SelectTargetCoroutine());
					<proximitySqr>5__2 = CS$<>8__locals0.proximityThreshold * CS$<>8__locals0.proximityThreshold;
					<nextValidCheck>5__3 = Time.timeSinceLevelLoad + 0.2f;
					<lowestPathDistance>5__4 = float.MaxValue;
					<stuckChecks>5__5 = 0;
					goto IL_0335;
				case 5:
					{
						<>1__state = -1;
						goto IL_0335;
					}
					IL_0335:
					if (CS$<>8__locals0.searchCoroutine != null && ((NetworkBehaviour)CS$<>8__locals0.ai).IsOwner && CS$<>8__locals0.ai.NpcController != null && (Object)(object)CS$<>8__locals0.currentTarget != (Object)null)
					{
						if (((EnemyAI)CS$<>8__locals0.ai).agent.isOnNavMesh)
						{
							if (((EnemyAI)CS$<>8__locals0.ai).agent.remainingDistance <= 1f)
							{
								Vector3 val = ((Component)CS$<>8__locals0.ai).transform.position - CS$<>8__locals0.currentTarget.transform.position;
								if (((Vector3)(ref val)).sqrMagnitude < <proximitySqr>5__2)
								{
									int num2 = CS$<>8__locals0.unsearchedNodes.FindIndex((GameObject? x) => (Object)(object)x == (Object)(object)CS$<>8__locals0.currentTarget);
									if (num2 != -1)
									{
										CS$<>8__locals0.unsearchedNodes[num2] = null;
										CS$<>8__locals0.unsearchedNodesHasNullRef = true;
									}
									goto IL_0368;
								}
							}
							if (Time.timeSinceLevelLoad > <nextValidCheck>5__3)
							{
								if (CS$<>8__locals0.ai.IsValidPathToTarget(CS$<>8__locals0.currentTarget.transform.position, calculatePathDistance: true) && ((EnemyAI)CS$<>8__locals0.ai).pathDistance < <lowestPathDistance>5__4)
								{
									<stuckChecks>5__5 = 0;
									<lowestPathDistance>5__4 = ((EnemyAI)CS$<>8__locals0.ai).pathDistance - 0.5f;
								}
								else
								{
									<stuckChecks>5__5++;
								}
								if (<stuckChecks>5__5 >= 20)
								{
									CS$<>8__locals0.currentTarget = null;
									if (CS$<>8__locals0.searchCenterFollowsAI)
									{
										CS$<>8__locals0.nextTarget = null;
									}
									goto IL_0368;
								}
								<nextValidCheck>5__3 += 0.2f;
							}
							if ((Object)(object)CS$<>8__locals0.nextTarget == (Object)null && !CS$<>8__locals0.isSelectingTarget)
							{
								CS$<>8__locals0.PopulateNodes();
								CS$<>8__locals0.selectTargetCoroutine = ((MonoBehaviour)CS$<>8__locals0.ai).StartCoroutine(CS$<>8__locals0.SelectTargetCoroutine());
							}
						}
						<>2__current = null;
						<>1__state = 5;
						return true;
					}
					goto IL_0368;
					IL_00f0:
					if (CS$<>8__locals0.isSelectingTarget)
					{
						<>2__current = null;
						<>1__state = 3;
						return true;
					}
					goto IL_010d;
					IL_010d:
					if ((Object)(object)CS$<>8__locals0.currentTarget == (Object)null)
					{
						CS$<>8__locals0.PopulateNodes();
						goto IL_0368;
					}
					CS$<>8__locals0.isWaitingTarget = false;
					<>2__current = CS$<>8__locals0.UpdateSearchCenter();
					<>1__state = 4;
					return true;
					IL_0368:
					if (CS$<>8__locals0.searchCoroutine == null || !((NetworkBehaviour)CS$<>8__locals0.ai).IsOwner || CS$<>8__locals0.ai.NpcController == null)
					{
						break;
					}
					if ((Object)(object)CS$<>8__locals0.nextTarget == (Object)null || !CS$<>8__locals0.ai.IsValidPathToTarget(CS$<>8__locals0.nextTarget.transform.position))
					{
						CS$<>8__locals0.nextTarget = null;
						CS$<>8__locals0.isWaitingTarget = true;
						<>2__current = CS$<>8__locals0.UpdateSearchCenter();
						<>1__state = 2;
						return true;
					}
					CS$<>8__locals0.currentTarget = CS$<>8__locals0.nextTarget;
					CS$<>8__locals0.nextTarget = null;
					goto IL_010d;
				}
				CS$<>8__locals0.StopSearch();
				return false;
			}

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

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

		[CompilerGenerated]
		private sealed class <SelectTargetCoroutine>d__31 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public LethalBotSearchRoutine <>4__this;

			private float <closestDist>5__2;

			private float <closestDistSqr>5__3;

			private GameObject <selectedNode>5__4;

			private int <iterAmount>5__5;

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

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

			[DebuggerHidden]
			public <SelectTargetCoroutine>d__31(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<selectedNode>5__4 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_012f: Unknown result type (might be due to invalid IL or missing references)
				//IL_013a: Unknown result type (might be due to invalid IL or missing references)
				//IL_013f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0144: Unknown result type (might be due to invalid IL or missing references)
				//IL_015b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0166: Unknown result type (might be due to invalid IL or missing references)
				//IL_01af: Unknown result type (might be due to invalid IL or missing references)
				//IL_01ba: Unknown result type (might be due to invalid IL or missing references)
				int num = <>1__state;
				LethalBotSearchRoutine lethalBotSearchRoutine = <>4__this;
				GameObject val;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					lethalBotSearchRoutine.isSelectingTarget = true;
					<>2__current = null;
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					goto IL_0251;
				case 2:
					{
						<>1__state = -1;
						goto IL_00b9;
					}
					IL_0251:
					if (lethalBotSearchRoutine.selectTargetCoroutine == null)
					{
						break;
					}
					<closestDist>5__2 = lethalBotSearchRoutine.searchRadius;
					<closestDistSqr>5__3 = lethalBotSearchRoutine.searchRadius * lethalBotSearchRoutine.searchRadius;
					<selectedNode>5__4 = null;
					<iterAmount>5__5 = 0;
					lethalBotSearchRoutine.targetCheckIndex = lethalBotSearchRoutine.unsearchedNodes.Count - 1;
					goto IL_0200;
					IL_0200:
					if (lethalBotSearchRoutine.targetCheckIndex >= 0)
					{
						if (<iterAmount>5__5 >= 10)
						{
							<iterAmount>5__5 = 0;
							<>2__current = null;
							<>1__state = 2;
							return true;
						}
						goto IL_00b9;
					}
					if (!((Object)(object)<selectedNode>5__4 != (Object)null) || lethalBotSearchRoutine.unsearchedNodes.Contains(<selectedNode>5__4))
					{
						if (lethalBotSearchRoutine.isWaitingTarget)
						{
							lethalBotSearchRoutine.currentTarget = <selectedNode>5__4;
						}
						else
						{
							lethalBotSearchRoutine.nextTarget = <selectedNode>5__4;
						}
						break;
					}
					goto IL_0251;
					IL_00b9:
					val = lethalBotSearchRoutine.unsearchedNodes[lethalBotSearchRoutine.targetCheckIndex];
					if ((Object)(object)val == (Object)null)
					{
						lethalBotSearchRoutine.unsearchedNodesHasNullRef = true;
					}
					else if (!((Object)(object)val == (Object)(object)lethalBotSearchRoutine.currentTarget) && ((Object)(object)<selectedNode>5__4 == (Object)null || lethalBotSearchRoutine.nodeChance >= 1f || Random.value < lethalBotSearchRoutine.nodeChance))
					{
						<iterAmount>5__5++;
						Vector3 val2 = lethalBotSearchRoutine.searchCenter - val.transform.position;
						float sqrMagnitude = ((Vector3)(ref val2)).sqrMagnitude;
						NavMeshHit val3 = default(NavMeshHit);
						if (sqrMagnitude < <closestDistSqr>5__3 && LethalBotAI.IsValidPathToTarget(lethalBotSearchRoutine.searchCenter, val.transform.position, ((EnemyAI)lethalBotSearchRoutine.ai).agent.areaMask, ref ((EnemyAI)lethalBotSearchRoutine.ai).path1, calculatePathDistance: true, out var pathDistance) && pathDistance < <closestDist>5__2 && pathDistance >= lethalBotSearchRoutine.minimumPathDistance && (!(pathDistance <= lethalBotSearchRoutine.proximityThreshold) || !NavMesh.Raycast(lethalBotSearchRoutine.searchCenter, val.transform.position, ref val3, ((EnemyAI)lethalBotSearchRoutine.ai).agent.areaMask)))
						{
							<selectedNode>5__4 = val;
							<closestDist>5__2 = pathDistance;
							<closestDistSqr>5__3 = pathDistance * pathDistance;
						}
					}
					lethalBotSearchRoutine.targetCheckIndex--;
					goto IL_0200;
				}
				lethalBotSearchRoutine.isSelectingTarget = false;
				return false;
			}

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

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

		[CompilerGenerated]
		private sealed class <UpdateSearchCenter>d__30 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public LethalBotSearchRoutine <>4__this;

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

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

			[DebuggerHidden]
			public <UpdateSearchCenter>d__30(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0080: Unknown result type (might be due to invalid IL or missing references)
				//IL_0074: Unknown result type (might be due to invalid IL or missing references)
				//IL_0085: Unknown result type (might be due to invalid IL or missing references)
				//IL_0087: Unknown result type (might be due to invalid IL or missing references)
				//IL_008c: Unknown result type (might be due to invalid IL or missing references)
				//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
				//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
				int num = <>1__state;
				LethalBotSearchRoutine lethalBotSearchRoutine = <>4__this;
				if (num != 0)
				{
					if (num != 1)
					{
						return false;
					}
					<>1__state = -1;
				}
				else
				{
					<>1__state = -1;
					if (!((Object)(object)lethalBotSearchRoutine.currentTarget == (Object)null) && lethalBotSearchRoutine.searchCenterFollowsAI)
					{
						goto IL_005f;
					}
				}
				if (!((EnemyAI)lethalBotSearchRoutine.ai).agent.isOnNavMesh)
				{
					<>2__current = null;
					<>1__state = 1;
					return true;
				}
				goto IL_005f;
				IL_005f:
				GameObject? currentTarget = lethalBotSearchRoutine.currentTarget;
				Vector3 val = ((currentTarget != null) ? currentTarget.transform.position : ((Component)lethalBotSearchRoutine.ai).transform.position);
				if (lethalBotSearchRoutine.searchCenter != val && (lethalBotSearchRoutine.searchCenterFollowsAI || !lethalBotSearchRoutine.ai.IsValidPathToTarget(lethalBotSearchRoutine.searchCenter)))
				{
					lethalBotSearchRoutine.searchCenter = val;
					if (lethalBotSearchRoutine.isSelectingTarget)
					{
						((MonoBehaviour)lethalBotSearchRoutine.ai).StopCoroutine(lethalBotSearchRoutine.selectTargetCoroutine);
						lethalBotSearchRoutine.isSelectingTarget = false;
					}
				}
				return false;
			}

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

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

		[CompilerGenerated]
		private sealed class <VisitCoroutine>d__32 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public LethalBotSearchRoutine <>4__this;

			private Vector3 <lastVisitCheckPos>5__2;

			private float <proximitySqr>5__3;

			private float <checkDist>5__4;

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

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

			[DebuggerHidden]
			public <VisitCoroutine>d__32(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0053: Unknown result type (might be due to invalid IL or missing references)
				//IL_0058: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
				//IL_00be: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
				//IL_0120: Unknown result type (might be due to invalid IL or missing references)
				//IL_012c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0131: Unknown result type (might be due to invalid IL or missing references)
				//IL_0136: Unknown result type (might be due to invalid IL or missing references)
				//IL_0281: Unknown result type (might be due to invalid IL or missing references)
				//IL_0286: Unknown result type (might be due to invalid IL or missing references)
				//IL_0154: Unknown result type (might be due to invalid IL or missing references)
				//IL_0160: Unknown result type (might be due to invalid IL or missing references)
				//IL_0175: Unknown result type (might be due to invalid IL or missing references)
				//IL_017a: Unknown result type (might be due to invalid IL or missing references)
				//IL_019e: Unknown result type (might be due to invalid IL or missing references)
				//IL_01aa: Unknown result type (might be due to invalid IL or missing references)
				//IL_01af: Unknown result type (might be due to invalid IL or missing references)
				//IL_01b9: Unknown result type (might be due to invalid IL or missing references)
				//IL_01be: Unknown result type (might be due to invalid IL or missing references)
				int num = <>1__state;
				LethalBotSearchRoutine lethalBotSearchRoutine = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					lethalBotSearchRoutine.visitInProgress = true;
					<>2__current = null;
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<lastVisitCheckPos>5__2 = ((Component)lethalBotSearchRoutine.ai).transform.position;
					<proximitySqr>5__3 = lethalBotSearchRoutine.proximityThreshold * lethalBotSearchRoutine.proximityThreshold;
					<checkDist>5__4 = lethalBotSearchRoutine.proximityThreshold / 2f;
					break;
				case 2:
					<>1__state = -1;
					break;
				}
				if (lethalBotSearchRoutine.visitNodesCoroutine != null)
				{
					int num2;
					Vector3 val;
					if (!((EnemyAI)lethalBotSearchRoutine.ai).agent.isOnNavMesh)
					{
						num2 = 0;
					}
					else
					{
						float num3 = lethalBotSearchRoutine.unsearchedNodes.Count;
						val = ((Component)lethalBotSearchRoutine.ai).transform.position - <lastVisitCheckPos>5__2;
						num2 = (int)Mathf.Ceil(Mathf.Lerp(0f, num3, Mathf.Min(((Vector3)(ref val)).magnitude / <checkDist>5__4, 1f)));
					}
					int num4 = num2;
					for (int i = 0; i < num4; i++)
					{
						GameObject val2 = lethalBotSearchRoutine.unsearchedNodes[lethalBotSearchRoutine.visitCheckIndex];
						if ((Object)(object)val2 != (Object)null)
						{
							val = ((Component)lethalBotSearchRoutine.ai).transform.position - val2.transform.position;
							if (((Vector3)(ref val)).sqrMagnitude < <proximitySqr>5__3 && Vector3.Angle(((EnemyAI)lethalBotSearchRoutine.ai).eye.forward, val2.transform.position - ((Component)((EnemyAI)lethalBotSearchRoutine.ai).eye).transform.position) < 90f && Physics.Linecast(((Component)((EnemyAI)lethalBotSearchRoutine.ai).eye).transform.position, val2.transform.position + Vector3.up * 0.2f, StartOfRound.Instance.collidersAndRoomMaskAndDefault, (QueryTriggerInteraction)1))
							{
								lethalBotSearchRoutine.unsearchedNodes[lethalBotSearchRoutine.visitCheckIndex] = null;
								lethalBotSearchRoutine.unsearchedNodesHasNullRef = true;
								if ((Object)(object)lethalBotSearchRoutine.nextTarget == (Object)(object)val2)
								{
									lethalBotSearchRoutine.nextTarget = null;
									lethalBotSearchRoutine.selectTargetCoroutine = ((MonoBehaviour)lethalBotSearchRoutine.ai).StartCoroutine(lethalBotSearchRoutine.SelectTargetCoroutine());
								}
							}
						}
						else
						{
							lethalBotSearchRoutine.unsearchedNodesHasNullRef = true;
						}
						lethalBotSearchRoutine.visitCheckIndex--;
						if (lethalBotSearchRoutine.visitCheckIndex < 0)
						{
							lethalBotSearchRoutine.visitCheckIndex = lethalBotSearchRoutine.unsearchedNodes.Count - 1;
						}
					}
					lethalBotSearchRoutine.TrimVisitedNodes();
					if (lethalBotSearchRoutine.unsearchedNodes.Count == 0)
					{
						lethalBotSearchRoutine.PopulateNodes();
					}
					<lastVisitCheckPos>5__2 = ((Component)lethalBotSearchRoutine.ai).transform.position;
					<>2__current = null;
					<>1__state = 2;
					return true;
				}
				lethalBotSearchRoutine.visitInProgress = false;
				return false;
			}

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

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

		private LethalBotAI ai;

		private Coroutine? searchCoroutine;

		private Coroutine? selectTargetCoroutine;

		private Coroutine? visitNodesCoroutine;

		private bool isWaitingTarget;

		private bool isSelectingTarget;

		private GameObject? currentTarget;

		private GameObject? nextTarget;

		private int targetCheckIndex;

		private int visitCheckIndex;

		private bool unsearchedNodesHasNullRef;

		public bool searchInProgress;

		public bool searchCenterFollowsAI;

		public Vector3 searchCenter;

		public float searchRadius;

		public float proximityThreshold;

		public float minimumPathDistance;

		public float nodeChance;

		public bool visitInProgress;

		private List<GameObject?> unsearchedNodes { get; set; }

		public LethalBotSearchRoutine(LethalBotAI ai)
		{
			this.ai = ai;
			unsearchedNodes = new List<GameObject>();
			searchCenterFollowsAI = true;
			searchRadius = float.MaxValue;
			proximityThreshold = 5f;
			nodeChance = 0.65f;
			base..ctor();
		}

		public void StartSearch()
		{
			if (!searchInProgress)
			{
				searchCoroutine = ((MonoBehaviour)ai).StartCoroutine(SearchCoroutine());
			}
			StartVisit();
		}

		public void StartVisit()
		{
			if (proximityThreshold > 0f && !visitInProgress)
			{
				visitNodesCoroutine = ((MonoBehaviour)ai).StartCoroutine(VisitCoroutine());
			}
		}

		public void StopSearch(bool clearVisited = false, bool clearTarget = true)
		{
			if (searchCoroutine != null)
			{
				((MonoBehaviour)ai).StopCoroutine(searchCoroutine);
			}
			if (selectTargetCoroutine != null)
			{
				((MonoBehaviour)ai).StopCoroutine(selectTargetCoroutine);
			}
			if (visitNodesCoroutine != null)
			{
				((MonoBehaviour)ai).StopCoroutine(visitNodesCoroutine);
			}
			searchInProgress = false;
			isWaitingTarget = false;
			isSelectingTarget = false;
			targetCheckIndex = 0;
			if (clearTarget)
			{
				currentTarget = null;
				nextTarget = null;
			}
			visitInProgress = false;
			if (clearVisited)
			{
				unsearchedNodes.Clear();
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public Vector3? GetTargetPosition(bool current = true)
		{
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			if (!current)
			{
				GameObject? obj = nextTarget;
				if (obj == null)
				{
					return null;
				}
				return obj.transform.position;
			}
			GameObject? obj2 = currentTarget;
			if (obj2 == null)
			{
				return null;
			}
			return obj2.transform.position;
		}

		[IteratorStateMachine(typeof(<SearchCoroutine>d__28))]
		private IEnumerator SearchCoroutine()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <SearchCoroutine>d__28(0)
			{
				<>4__this = this
			};
		}

		private void PopulateNodes()
		{
			unsearchedNodes = ((EnemyAI)ai).allAINodes.ToList();
			if (nodeChance < 1f || minimumPathDistance > 0f)
			{
				int num = unsearchedNodes.Count;
				while (num > 1)
				{
					num--;
					int num2 = Random.Range(0, num + 1);
					List<GameObject> list = unsearchedNodes;
					int index = num2;
					List<GameObject?> list2 = unsearchedNodes;
					int index2 = num;
					GameObject value = unsearchedNodes[num];
					GameObject value2 = unsearchedNodes[num2];
					list[index] = value;
					list2[index2] = value2;
				}
			}
			targetCheckIndex = 0;
			if (isSelectingTarget)
			{
				((MonoBehaviour)ai).StopCoroutine(selectTargetCoroutine);
				selectTargetCoroutine = ((MonoBehaviour)ai).StartCoroutine(SelectTargetCoroutine());
			}
			visitCheckIndex = unsearchedNodes.Count - 1;
			unsearchedNodesHasNullRef = false;
		}

		[IteratorStateMachine(typeof(<UpdateSearchCenter>d__30))]
		private IEnumerator UpdateSearchCenter()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <UpdateSearchCenter>d__30(0)
			{
				<>4__this = this
			};
		}

		[IteratorStateMachine(typeof(<SelectTargetCoroutine>d__31))]
		private IEnumerator SelectTargetCoroutine()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <SelectTargetCoroutine>d__31(0)
			{
				<>4__this = this
			};
		}

		[IteratorStateMachine(typeof(<VisitCoroutine>d__32))]
		private IEnumerator VisitCoroutine()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <VisitCoroutine>d__32(0)
			{
				<>4__this = this
			};
		}

		private void TrimVisitedNodes()
		{
			if (!unsearchedNodesHasNullRef)
			{
				return;
			}
			for (int num = Mathf.Max(visitCheckIndex, targetCheckIndex) - 1; num >= 0; num--)
			{
				if ((Object)(object)unsearchedNodes[num] == (Object)null)
				{
					if (targetCheckIndex > num)
					{
						targetCheckIndex--;
					}
					if (visitCheckIndex > num)
					{
						visitCheckIndex--;
					}
				}
			}
			if (visitCheckIndex < 0)
			{
				visitCheckIndex = unsearchedNodes.Count - 1;
			}
			unsearchedNodes.RemoveAll((GameObject? x) => (Object)(object)x == (Object)null);
			unsearchedNodes.TrimExcess();
			unsearchedNodesHasNullRef = false;
		}
	}
	public class LethalBotStockRequirement
	{
		public int Id { get; }

		public string Name => Item?.itemName ?? "Invalid Item";

		public Item? Item { get; }

		public int RequiredStock { get; }

		public bool OverrideEcoLimit { get; }

		public int EcoLimit { get; }

		public IReadOnlyList<LethalBotStockRequiredItem> RequiredItems { get; }

		public LethalBotStockRequirement(int id, Item? item, int requiredStock, bool overrideEcoLimit, int ecoLimit, List<LethalBotStockRequiredItem> requiredItems)
		{
			Id = id;
			Item = item;
			RequiredStock = requiredStock;
			OverrideEcoLimit = overrideEcoLimit;
			EcoLimit = ecoLimit;
			RequiredItems = requiredItems;
		}

		public override string ToString()
		{
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.AppendLine($"Id: {Id}");
			stringBuilder.AppendLine("Item: " + Name);
			stringBuilder.AppendLine($"Required Stock: {RequiredStock}");
			stringBuilder.AppendLine($"Override Eco Limit: {OverrideEcoLimit}");
			stringBuilder.AppendLine($"Eco Limit: {EcoLimit}");
			stringBuilder.AppendLine("Required Items:");
			if (RequiredItems.Count == 0)
			{
				stringBuilder.AppendLine("(None)");
			}
			else
			{
				foreach (LethalBotStockRequiredItem requiredItem in RequiredItems)
				{
					stringBuilder.AppendLine($"{requiredItem}");
				}
			}
			return stringBuilder.ToString();
		}
	}
	public class LethalBotStockRequiredItem
	{
		public string Name => Item?.itemName ?? "Invalid Item";

		public Item? Item { get; }

		public int RequiredStock { get; }

		public LethalBotStockRequiredItem(Item item, int requiredStock)
		{
			Item = item;
			RequiredStock = requiredStock;
		}

		public override string ToString()
		{
			return $"Item Name: {Name} and Requred Stock: {RequiredStock}";
		}
	}
	public class LethalBotThreat
	{
		private readonly Func<LethalBotFearQuery, float?> panikFearRange;

		private readonly Func<LethalBotFearQuery, float?> missionControlFearRange;

		private readonly Func<LethalBotFearQuery, float?> pathfindingFearRange;

		public Type ThreatType { get; private set; }

		public LethalBotThreat(EnemyAI enemyAI, Func<LethalBotFearQuery, float?> pankFunc, Func<LethalBotFearQuery, float?> missionControlFunc, Func<LethalBotFearQuery, float?> pathfindFunc)
			: this(((object)enemyAI).GetType(), pankFunc, missionControlFunc, pathfindFunc)
		{
		}

		public LethalBotThreat(Type threatType, Func<LethalBotFearQuery, float?> pankFunc, Func<LethalBotFearQuery, float?> missionControlFunc, Func<LethalBotFearQuery, float?> pathfindFunc)
		{
			ThreatType = threatType;
			panikFearRange = pankFunc;
			missionControlFearRange = missionControlFunc;
			pathfindingFearRange = pathfindFunc;
		}

		public float? GetFearRangeForEnemy(LethalBotFearQuery fearQuery)
		{
			switch (fearQuery.QueryType)
			{
			case EnumFearQueryType.BotPanic:
				return panikFearRange?.Invoke(fearQuery);
			case EnumFearQueryType.PlayerTeleport:
				return missionControlFearRange?.Invoke(fearQuery);
			case EnumFearQueryType.PathfindingAvoid:
				return pathfindingFearRange?.Invoke(fearQuery);
			default:
				Plugin.LogError($"Unknown fear query type: {fearQuery.QueryType}");
				return null;
			}
		}
	}
	public class LethalBotVoice
	{
		public int averageCount;

		public float averageVoiceAmplitude;

		public float voiceChatNoiseCooldown;

		public static LethalBotTalkEvent lethalBotTalkEvent = new LethalBotTalkEvent();

		private float cooldownPlayAudio;

		private float[] leftSamples = new float[256];

		private float[] rightSamples = new float[256];

		private bool aboutToTalk;

		private Dictionary<EnumVoicesState, List<string>> dictAvailableAudioClipPathsByState = new Dictionary<EnumVoicesState, List<string>>();

		private Dictionary<EnumVoicesState, List<string>> availableAudioClipPaths = new Dictionary<EnumVoicesState, List<string>>();

		private bool wasInside;

		private bool wasAllowedToSwear;

		public int BotID { get; set; }

		public string VoiceFolder { get; set; }

		public float Volume { get; set; }

		public float VoicePitch { get; set; }

		public AudioSource CurrentAudioSource { get; set; }

		public EnumVoicesState LastVoiceState { get; private set; }

		public LethalBotVoice(string voiceFolder, float volume, float voicePitch)
		{
			VoiceFolder = voiceFolder;
			Volume = volume;
			VoicePitch = voicePitch;
		}

		public override string ToString()
		{
			return $"BotID: {BotID}, VoiceFolder: {VoiceFolder}, Volume: {Volume}, VoicePitch {VoicePitch}";
		}

		public void SetCooldownAudio(float cooldown)
		{
			cooldownPlayAudio = cooldown;
		}

		public void SetNewRandomCooldownAudio()
		{
			cooldownPlayAudio = GetRandomCooldown();
		}

		public void ReduceCooldown(float time)
		{
			if (cooldownPlayAudio > 0f)
			{
				cooldownPlayAudio -= time;
			}
			if (cooldownPlayAudio < 0f)
			{
				cooldownPlayAudio = 0f;
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public bool CanPlayAudioAfterCooldown()
		{
			return cooldownPlayAudio == 0f;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public bool IsTalking()
		{
			if (!CurrentAudioSource.isPlaying)
			{
				return aboutToTalk;
			}
			return true;
		}

		public float GetVoiceAmplitude()
		{
			if ((Object)(object)CurrentAudioSource == (Object)null || !CurrentAudioSource.isPlaying)
			{
				return 0f;
			}
			CurrentAudioSource.GetOutputData(leftSamples, 0);
			CurrentAudioSource.GetOutputData(rightSamples, 1);
			float num = 0f;
			float num2 = 0f;
			float[] array = leftSamples;
			foreach (float num3 in array)
			{
				num += num3 * num3;
			}
			float[] array2 = rightSamples;
			foreach (float num4 in array2)
			{
				num2 += num4 * num4;
			}
			float num5 = Mathf.Sqrt(num / (float)leftSamples.Length);
			float num6 = Mathf.Sqrt(num2 / (float)rightSamples.Length);
			return Mathf.Clamp01((num5 + num6) / 2f);
		}

		public void TryPlayVoiceAudio(PlayVoiceParameters parameters)
		{
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			if (Plugin.Config.Talkativeness.Value == 0)
			{
				return;
			}
			if (!parameters.CanTalkIfOtherLethalBotTalk && LethalBotManager.Instance.DidAnLethalBotJustTalkedClose(BotID))
			{
				SetNewRandomCooldownAudio();
			}
			else
			{
				if ((parameters.WaitForCooldown && !CanPlayAudioAfterCooldown()) || (!parameters.CutCurrentVoiceStateToTalk && IsTalking()))
				{
					return;
				}
				if (parameters.CanRepeatVoiceState)
				{
					if (LastVoiceState == parameters.VoiceState && IsTalking())
					{
						return;
					}
				}
				else if (LastVoiceState == parameters.VoiceState)
				{
					return;
				}
				PlayRandomVoiceAudio(parameters.VoiceState, parameters);
				LastVoiceState = parameters.VoiceState;
				LethalBotManager.Instance.PlayAudibleNoiseForLethalBot(BotID, ((Component)CurrentAudioSource).transform.position, 16f, 0.9f, 5);
			}
		}

		public void PlayRandomVoiceAudio(EnumVoicesState enumVoicesState, PlayVoiceParameters parameters)
		{
			StopAudioFadeOut();
			ResetAboutToTalk();
			string randomAudioClipByState = GetRandomAudioClipByState(enumVoicesState, parameters);
			if (!string.IsNullOrWhiteSpace(randomAudioClipByState))
			{
				aboutToTalk = true;
				if (parameters.ShouldSync)
				{
					AudioManager.Instance.SyncPlayAudio(randomAudioClipByState, BotID);
				}
				else
				{
					AudioManager.Instance.PlayAudio(randomAudioClipByState, this);
				}
			}
		}

		public void PlayAudioClip(AudioClip audioClip)
		{
			ResetAboutToTalk();
			CurrentAudioSource.clip = audioClip;
			CurrentAudioSource.Play();
			SetCooldownAudio(audioClip.length + GetRandomCooldown());
		}

		private float GetRandomCooldown()
		{
			Random random = new Random();
			return Plugin.Config.Talkativeness.Value switch
			{
				1 => random.Next(10, 40), 
				2 => random.Next(5, 20), 
				3 => random.Next(2, 10), 
				4 => random.Next(0, 0), 
				_ => 0f, 
			};
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void ResetAboutToTalk()
		{
			aboutToTalk = false;
		}

		private string GetRandomAudioClipByState(EnumVoicesState enumVoicesState, PlayVoiceParameters parameters)
		{
			if (!dictAvailableAudioClipPathsByState.ContainsKey(enumVoicesState))
			{
				dictAvailableAudioClipPathsByState.Add(enumVoicesState, LoadAudioClipPathsByState(enumVoicesState).ToList());
			}
			if (!availableAudioClipPaths.ContainsKey(enumVoicesState))
			{
				availableAudioClipPaths.Add(enumVoicesState, FilterAudioClipPaths(dictAvailableAudioClipPathsByState[enumVoicesState], parameters).ToList());
			}
			else if (DidParametersChanged(parameters))
			{
				availableAudioClipPaths[enumVoicesState].Clear();
			}
			if (availableAudioClipPaths[enumVoicesState].Count == 0)
			{
				availableAudioClipPaths[enumVoicesState] = FilterAudioClipPaths(dictAvailableAudioClipPathsByState[enumVoicesState], parameters).ToList();
			}
			List<string> list = availableAudioClipPaths[enumVoicesState];
			if (list.Count == 0)
			{
				return string.Empty;
			}
			Random random = new Random();
			int index = random.Next(0, list.Count);
			string result = list[index];
			list.RemoveAt(index);
			return result;
		}

		private IEnumerable<string> FilterAudioClipPaths(List<string> audioClipPaths, PlayVoiceParameters parameters)
		{
			IEnumerable<string> source = audioClipPaths.AsEnumerable();
			if (!parameters.AllowSwearing)
			{
				source = source.Where((string x) => !x.ToLower().Contains("_cuss".ToLower()));
			}
			if (parameters.IsLethalBotInside)
			{
				return source.Where((string x) => !x.ToLower().Contains("_outside".ToLower()));
			}
			return source.Where((string x) => !x.ToLower().Contains("_inside".ToLower()));
		}

		private bool DidParametersChanged(PlayVoiceParameters parameters)
		{
			bool result = false;
			if (wasInside != parameters.IsLethalBotInside)
			{
				wasInside = parameters.IsLethalBotInside;
				result = true;
			}
			if (wasAllowedToSwear != parameters.AllowSwearing)
			{
				wasAllowedToSwear = parameters.AllowSwearing;
				result = true;
			}
			return result;
		}

		private string[] LoadAudioClipPathsByState(EnumVoicesState enumVoicesState)
		{
			string path = string.Join(' ', VoiceFolder + "\\" + enumVoicesState).Replace("_", "").ToLower();
			IEnumerable<KeyValuePair<string, AudioClip>> source = AudioManager.Instance.DictAudioClipsByPath.Where<KeyValuePair<string, AudioClip>>((KeyValuePair<string, AudioClip> x) => x.Key.Replace(" ", "").Replace("_", "").ToLower()
				.Contains(path));
			Plugin.LogDebug($"Loaded {source.Count()} path containing {path}");
			return source.Select((KeyValuePair<string, AudioClip> y) => y.Key).ToArray();
		}

		public void ResetAvailableAudioPaths()
		{
			dictAvailableAudioClipPathsByState.Clear();
			availableAudioClipPaths.Clear();
		}

		public void TryStopAudioFadeOut()
		{
			if (LastVoiceState != EnumVoicesState.Hit && LastVoiceState != EnumVoicesState.SteppedOnTrap && LastVoiceState != EnumVoicesState.RunningFromMonster)
			{
				StopAudioFadeOut();
			}
		}

		public void StopAudioFadeOut()
		{
			if (CurrentAudioSource.isPlaying)
			{
				CurrentAudioSource.Stop();
				LastVoiceState = EnumVoicesState.None;
			}
		}
	}
	public struct PlayVoiceParameters
	{
		public bool CanTalkIfOtherLethalBotTalk { get; set; }

		public bool WaitForCooldown { get; set; }

		public bool CutCurrentVoiceStateToTalk { get; set; }

		public bool CanRepeatVoiceState { get; set; }

		public EnumVoicesState VoiceState { get; set; }

		public bool ShouldSync { get; set; }

		public bool IsLethalBotInside { get; set; }

		public bool AllowSwearing { get; set; }
	}
	public class NpcController
	{
		public class TimedGetBounds
		{
			private Bounds bounds;

			private GameObject? model;

			private long timer = 100000000L;

			private long lastTimeCalculate;

			public Bounds GetBoundsModel(GameObject model)
			{
				//IL_002c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0017: Unknown result type (might be due to invalid IL or missing references)
				if ((Object)(object)model == (Object)(object)this.model && !NeedToRecalculate())
				{
					return bounds;
				}
				this.model = model;
				CalculateBoundsModel(model);
				return bounds;
			}

			private bool NeedToRecalculate()
			{
				long num = DateTime.Now.Ticks - lastTimeCalculate;
				if (num > timer)
				{
					lastTimeCalculate = DateTime.Now.Ticks;
					return true;
				}
				return false;
			}

			private void CalculateBoundsModel(GameObject model)
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_005c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0061: Unknown result type (might be due to invalid IL or missing references)
				//IL_0065: Unknown result type (might be due to invalid IL or missing references)
				//IL_0095: Unknown result type (might be due to invalid IL or missing references)
				//IL_009a: Unknown result type (might be due to invalid IL or missing references)
				//IL_009e: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
				//IL_0107: Unknown result type (might be due to invalid IL or missing references)
				//IL_010c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0110: Unknown result type (might be due to invalid IL or missing references)
				//IL_0141: Unknown result type (might be due to invalid IL or missing references)
				//IL_0146: Unknown result type (might be due to invalid IL or missing references)
				//IL_014a: Unknown result type (might be due to invalid IL or missing references)
				//IL_017b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0180: Unknown result type (might be due to invalid IL or missing references)
				//IL_0184: Unknown result type (might be due to invalid IL or missing references)
				//IL_019c: Unknown result type (might be due to invalid IL or missing references)
				//IL_01a4: Unknown result type (might be due to invalid IL or missing references)
				bounds = default(Bounds);
				IEnumerable<Bounds> source = from r in model.GetComponentsInChildren<SkinnedMeshRenderer>()
					select ((Renderer)r).bounds;
				Bounds val = source.OrderByDescending((Bounds x) => ((Bounds)(ref x)).max.x).First();
				float x2 = ((Bounds)(ref val)).max.x;
				val = source.OrderByDescending((Bounds x) => ((Bounds)(ref x)).max.y).First();
				float y = ((Bounds)(ref val)).max.y;
				val = source.OrderByDescending((Bounds x) => ((Bounds)(ref x)).max.z).First();
				float z = ((Bounds)(ref val)).max.z;
				val = source.OrderBy((Bounds x) => ((Bounds)(ref x)).min.x).First();
				float x3 = ((Bounds)(ref val)).min.x;
				val = source.OrderBy((Bounds x) => ((Bounds)(ref x)).min.y).First();
				float y2 = ((Bounds)(ref val)).min.y;
				val = source.OrderBy((Bounds x) => ((Bounds)(ref x)).min.z).First();
				float z2 = ((Bounds)(ref val)).min.z;
				((Bounds)(ref bounds)).SetMinMax(new Vector3(x3, y2, z2), new Vector3(x2, y, z));
			}
		}

		public class TimedSqrDistanceWithLocalPlayerCheck
		{
			private float sqrDistance;

			private long timer = 1000000L;

			private long lastTimeCalculate;

			public float GetSqrDistanceWithLocalPlayer(Vector3 lethalBotBodyPos)
			{
				//IL_0036: Unknown result type (might be due to invalid IL or missing references)
				if (!NeedToRecalculate())
				{
					return sqrDistance;
				}
				if ((Object)(object)StartOfRound.Instance == (Object)null || (Object)(object)StartOfRound.Instance.localPlayerController == (Object)null)
				{
					return sqrDistance;
				}
				CalculateSqrDistanceWithLocalPlayer(lethalBotBodyPos);
				return sqrDistance;
			}

			private bool NeedToRecalculate()
			{
				long num = DateTime.Now.Ticks - lastTimeCalculate;
				if (num > timer)
				{
					lastTimeCalculate = DateTime.Now.Ticks;
					return true;
				}
				return false;
			}

			private void CalculateSqrDistanceWithLocalPlayer(Vector3 lethalBotBodyPos)
			{
				//IL_0010: Unknown result type (might be due to invalid IL or missing references)
				//IL_0015: Unknown result type (might be due to invalid IL or missing references)
				//IL_0016: Unknown result type (might be due to invalid IL or missing references)
				//IL_001b: Unknown result type (might be due to invalid IL or missing references)
				Vector3 val = ((Component)StartOfRound.Instance.localPlayerController).transform.position - lethalBotBodyPos;
				sqrDistance = ((Vector3)(ref val)).sqrMagnitude;
			}
		}

		public class TimedUpdateBillboardLookAtCheck
		{
			private long timer = 1000000L;

			private long lastTimeCalculate;

			public void UpdateBillboardLookAt(PlayerControllerB player, bool forceUpdate)
			{
				if ((forceUpdate || NeedToRecalculate()) && !((Object)(object)StartOfRound.Instance == (Object)null) && !((Object)(object)StartOfRound.Instance.localPlayerController == (Object)null))
				{
					CalculateUpdateBillboardLookAt(player);
				}
			}

			private bool NeedToRecalculate()
			{
				long num = DateTime.Now.Ticks - lastTimeCalculate;
				if (num > timer)
				{
					lastTimeCalculate = DateTime.Now.Ticks;
					return true;
				}
				return false;
			}

			private void CalculateUpdateBillboardLookAt(PlayerControllerB player)
			{
				player.usernameBillboard.LookAt(StartOfRound.Instance.localPlayerController.localVisorTargetPoint);
			}
		}

		public List<PlayerPhysicsRegion> CurrentLethalBotPhysicsRegions = new List<PlayerPhysicsRegion>();

		public bool IsControllerInCruiser;

		public TimedSqrDistanceWithLocalPlayerCheck SqrDistanceWithLocalPlayerTimedCheck;

		public TimedGetBounds GetBoundsTimedCheck;

		public TimedUpdateBillboardLookAtCheck UpdateBillBoardLookAtTimedCheck;

		public bool IsCameraDisabled;

		public bool IsJumping;

		public bool IsFallingFromJump;

		public float CrouchMeter;

		public bool IsWalking;

		public float PlayerSlidingTimer;

		public float BloodDropTimer;

		public float LimpMultiplier = 0.2f;

		public bool DisabledJetpackControlsThisFrame;

		public bool StartedJetpackControls;

		public float UpperBodyAnimationsWeight;

		public Vector3 RightArmProceduralTargetBasePosition;

		public Overrideable<bool> ThrowingObject = new Overrideable<bool>(initialValue: false);

		public Overrideable<float> TimeSinceSwitchingSlots = new Overrideable<float>(0f);

		public float TimeSinceTakingGravityDamage;

		public bool TeleportingThisFrame;

		public float PreviousFrameDeltaTime;

		public float CameraUp;

		public OccludeAudio OccludeAudioComponent;

		public AudioLowPassFilter AudioLowPassFilterComponent;

		public AudioHighPassFilter AudioHighPassFilterComponent;

		public Vector3 MoveVector;

		public bool UpdatePositionForNewlyJoinedClient;

		public bool GrabbedObjectValidated;

		public float UpdatePlayerLookInterval;

		public int PlayerMask;

		public bool IsTouchingGround;

		public EnemyAI? EnemyInAnimationWith;

		public Vector3 NearEntitiesPushVector;

		[CompilerGenerated]
		private LethalBotAI <LethalBotAIController>k__BackingField;

		private int movementHinderedPrev;

		private float sprintMultiplier = 1f;

		private Vector3 walkForce;

		private bool isFallingNoJump;

		private Dictionary<string, bool> dictAnimationBoolPerItem;

		private float exhaustionEffectLerp;

		private bool disabledJetpackControlsThisFrame;

		private bool wasUnderwaterLastFrame;

		private bool setFaceUnderwater;

		private float syncUnderwaterInterval;

		private LookAtTarget oldLookAtTarget = new LookAtTarget();

		public Vector2 lastMoveVector;

		private float floatSprint;

		internal bool goDownLadder;

		private int[] animationHashLayers;

		private List<int> currentAnimationStateHash;

		private List<int> previousAnimationStateHash;

		private float updatePlayerAnimationsInterval;

		private float currentAnimationSpeed;

		private float previousAnimationSpeed;

		public PlayerControllerB Npc { get; set; }

		public bool HasToMove { get; private set; }

		private LethalBotAI LethalBotAIController
		{
			get
			{
				if ((Object)(object)<LethalBotAIController>k__BackingField == (Object)null)
				{
					<LethalBotAIController>k__BackingField = LethalBotManager.Instance.GetLethalBotAI(Npc);
					if ((Object)(object)<LethalBotAIController>k__BackingField == (Object)null)
					{
						throw new NullReferenceException(string.Format("{0} v{1}: error no lethalBotAI attached to NpcController playerClientId {2}.", "LethalBots", "7.1.0", Npc.playerClientId));
					}
				}
				return <LethalBotAIController>k__BackingField;
			}
		}

		public bool WaitForFullStamina { get; private set; }

		public float DrowningTimer { get; internal set; } = 1f;


		public LookAtTarget LookAtTarget { get; private set; } = new LookAtTarget();


		public NpcController(PlayerControllerB npc)
		{
			Npc = npc;
			Init();
		}

		public void Awake(bool clientJoining = false)
		{
			Init(clientJoining);
			PatchesUtil.FieldInfoPreviousAnimationStateHash.SetValue(Npc, new List<int>(new int[Npc.playerBodyAnimator.layerCount]));
			PatchesUtil.FieldInfoCurrentAnimationStateHash.SetValue(Npc, new List<int>(new int[Npc.playerBodyAnimator.layerCount]));
		}

		private void Init(bool clientJoining = false)
		{
			//IL_001d: 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_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_0128: Unknown result type (might be due to invalid IL or missing references)
			Npc.isHostPlayerObject = false;
			Npc.serverPlayerPosition = ((Component)Npc).transform.position;
			((Behaviour)Npc.gameplayCamera).enabled = false;
			((Behaviour)Npc.visorCamera).enabled = false;
			((Renderer)Npc.thisPlayerModel).enabled = true;
			((Renderer)Npc.thisPlayerModel).shadowCastingMode = (ShadowCastingMode)1;
			((Renderer)Npc.thisPlayerModelArms).enabled = false;
			IsCameraDisabled = true;
			Npc.sprintMeter = 1f;
			if (!clientJoining)
			{
				PlayerControllerB npc = Npc;
				if (npc.ItemSlots == null)
				{
					npc.ItemSlots = (GrabbableObject[])(object)new GrabbableObject[4];
				}
			}
			RightArmProceduralTargetBasePosition = Npc.rightArmProceduralTarget.localPosition;
			((TMP_Text)Npc.usernameBillboardText).text = Npc.playerUsername;
			Npc.usernameAlpha.alpha = 1f;
			((Component)Npc.usernameCanvas).gameObject.SetActive(true);
			Npc.previousElevatorPosition = Npc.playersManager.elevatorTransform.position;
			if (Object.op_Implicit((Object)(object)((Component)Npc).gameObject.GetComponent<Rigidbody>()))
			{
				((Component)Npc).gameObject.GetComponent<Rigidbody>().interpolation = (RigidbodyInterpolation)0;
			}
			((Collider)((Component)Npc).gameObject.GetComponent<CharacterController>()).enabled = true;
			AudioReverbPresets val = Object.FindObjectOfType<AudioReverbPresets>();
			if (Object.op_Implicit((Object)(object)val))
			{
				val.audioPresets[3].ChangeAudioReverbForPlayer(Npc);
			}
			SkinnedMeshRenderer[] componentsInChildren = ((Component)Npc).gameObject.GetComponentsInChildren<SkinnedMeshRenderer>();
			foreach (SkinnedMeshRenderer val2 in componentsInChildren)
			{
				val2.updateWhenOffscreen = false;
			}
			animationHashLayers = new int[Npc.playerBodyAnimator.layerCount];
			currentAnimationStateHash = new List<int>(new int[Npc.playerBodyAnimator.layerCount]);
			previousAnimationStateHash = new List<int>(new int[Npc.playerBodyAnimator.layerCount]);
			GetBoundsTimedCheck = new TimedGetBounds();
			SqrDistanceWithLocalPlayerTimedCheck = new TimedSqrDistanceWithLocalPlayerCheck();
			UpdateBillBoardLookAtTimedCheck = new TimedUpdateBillboardLookAtCheck();
		}

		public void Update()
		{
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0145: Unknown result type (might be due to invalid IL or missing references)
			//IL_016a: Unknown result type (might be due to invalid IL or missing references)
			StartOfRound instance = StartOfRound.Instance;
			if (LethalBotAIController.IsClientOwnerOfLethalBot() && Npc.isPlayerControlled)
			{
				UpdateOwnerChanged(isOwner: true);
				((RigConstraint<ChainIKConstraintJob, ChainIKConstraintData, ChainIKConstraintJobBinder<ChainIKConstraintData>>)(object)Npc.rightArmProceduralRig).weight = Mathf.Lerp(((RigConstraint<ChainIKConstraintJob, ChainIKConstraintData, ChainIKConstraintJobBinder<ChainIKConstraintData>>)(object)Npc.rightArmProceduralRig).weight, 0f, 25f * Time.deltaTime);
				UpdateMoveInputVectorForOwner();
				ForceTurnTowardsTarget();
				UpdateTurnBodyTowardsDirection();
				SetFaceUnderwaterFilters();
				UpdateWalkingStateForOwner();
				UpdateEmoteStateForOwner();
				UpdateSinkingStateForOwner();
				UpdateCenterAndHeightForOwner();
				UpdateJetPackControlsForOwner();
				if (!Npc.inSpecialInteractAnimation || Npc.inShockingMinigame || instance.suckingPlayersOutOfShip)
				{
					UpdateMoveControllerForOwner();
					UpdateFallValuesForOwner();
					Npc.externalForces = Vector3.zero;
					if (!TeleportingThisFrame && Npc.teleportedLastFrame)
					{
						Npc.ResetFallGravity();
						Npc.teleportedLastFrame = false;
					}
					UpdateJetPackMoveValuesForOwner();
				}
				else if (Npc.isClimbingLadder)
				{
					UpdateMoveWhenClimbingLadder();
				}
				TeleportingThisFrame = false;
				UpdateLookAt();
				Npc.playerEye.position = ((Component)Npc.gameplayCamera).transform.position;
				Npc.playerEye.rotation = ((Component)Npc.gameplayCamera).transform.rotation;
				if ((Object)(object)NetworkManager.Singleton != (Object)null && Npc.playersManager.connectedPlayersAmount > 0)
				{
					UpdatePlayerLookInterval += Time.deltaTime;
				}
				UpdateAnimationsForOwner();
			}
			else
			{
				UpdateOwnerChanged(isOwner: false);
				UpdateSyncPositionAndRotationForNotOwner();
				UpdateLethalBotAnimationsLocalForNotOwner(animationHashLayers);
			}
			TimeSinceSwitchingSlots.Apply((float)TimeSinceSwitchingSlots + Time.deltaTime);
			PlayerControllerB npc = Npc;
			npc.timeSincePlayerMoving += Time.deltaTime;
			PlayerControllerB npc2 = Npc;
			npc2.timeSinceMakingLoudNoise += Time.deltaTime;
			PlayerControllerB npc3 = Npc;
			npc3.timeSinceFearLevelUp += Time.deltaTime;
			UpdateInSpecialInteractAnimationEffect();
			UpdateEmoteEffects();
			UpdateSinkingEffects();
			UpdateActiveAudioReverbFilter();
			UpdateAnimationUpperBody();
			UpdateBleedEffects();
			UpdateStaminaTimer();
			UpdateDrunknessAndPoisonEffects();
			UpdateLineOfSightCube();
			PlayerControllerBPatch.SetPlayerSanityLevel_ReversePatch(Npc);
		}

		private void UpdateOwnerChanged(bool isOwner)
		{
			if (isOwner)
			{
				if (IsCameraDisabled)
				{
					IsCameraDisabled = false;
					((Behaviour)Npc.gameplayCamera).enabled = false;
					((Behaviour)Npc.visorCamera).enabled = false;
					((Renderer)Npc.thisPlayerModelArms).enabled = false;
					((Renderer)Npc.thisPlayerModel).shadowCastingMode = (ShadowCastingMode)1;
					((Renderer)Npc.mapRadarDirectionIndicator).enabled = false;
					((Collider)Npc.thisController).enabled = true;
					Npc.activeAudioReverbFilter = ((Component)Npc.activeAudioListener).GetComponent<AudioReverbFilter>();
					((Behaviour)Npc.activeAudioReverbFilter).enabled = true;
					UpdateRuntimeAnimatorController(isOwner);
				}
				PlayerControllerBPatch.SetNightVisionEnabled_ReversePatch(Npc, isNotLocalClient: true);
				return;
			}
			if (!IsCameraDisabled)
			{
				IsCameraDisabled = true;
				((Behaviour)Npc.gameplayCamera).enabled = false;
				((Behaviour)Npc.visorCamera).enabled = false;
				((Renderer)Npc.thisPlayerModel).shadowCastingMode = (ShadowCastingMode)1;
				((Renderer)Npc.thisPlayerModelArms).enabled = false;
				((Renderer)Npc.mapRadarDirectionIndicator).enabled = false;
				UpdateRuntimeAnimatorController(isOwner);
				((Collider)Npc.thisController).enabled = false;
				if (Object.op_Implicit((Object)(object)((Component)Npc).gameObject.GetComponent<Rigidbody>()))
				{
					((Component)Npc).gameObject.GetComponent<Rigidbody>().interpolation = (RigidbodyInterpolation)0;
				}
			}
			PlayerControllerBPatch.SetNightVisionEnabled_ReversePatch(Npc, isNotLocalClient: true);
		}

		private void UpdateRuntimeAnimatorController(bool isOwner)
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			AnimatorStateInfo[] array = (AnimatorStateInfo[])(object)new AnimatorStateInfo[Npc.playerBodyAnimator.layerCount];
			for (int i = 0; i < Npc.playerBodyAnimator.layerCount; i++)
			{
				array[i] = Npc.playerBodyAnimator.GetCurrentAnimatorStateInfo(i);
			}
			if (isOwner)
			{
				if ((Object)(object)Npc.playerBodyAnimator.runtimeAnimatorController != (Object)(object)Npc.playersManager.localClientAnimatorController)
				{
					Npc.playerBodyAnimator.runtimeAnimatorController = Npc.playersManager.localClientAnimatorController;
					AnimatorStateInfo currentAnimatorStateInfo = Npc.playerBodyAnimator.GetCurrentAnimatorStateInfo(5);
					if (!((AnimatorStateInfo)(ref currentAnimatorStateInfo)).IsTag("notInSpecialAnim"))
					{
						Npc.playerBodyAnimator.SetTrigger("SA_stopAnimation");
					}
				}
			}
			else if ((Object)(object)Npc.playerBodyAnimator.runtimeAnimatorController != (Object)(object)Npc.playersManager.otherClientsAnimatorController)
			{
				Npc.playerBodyAnimator.runtimeAnimatorController = Npc.playersManager.otherClientsAnimatorController;
			}
			for (int j = 0; j < Npc.playerBodyAnimator.layerCount; j++)
			{
				if (Npc.playerBodyAnimator.HasState(j, ((AnimatorStateInfo)(ref array[j])).fullPathHash))
				{
					Npc.playerBodyAnimator.CrossFadeInFixedTime(((AnimatorStateInfo)(ref array[j])).fullPathHash, 0.1f);
				}
			}
			if (dictAnimationBoolPerItem == null)
			{
				return;
			}
			foreach (KeyValuePair<string, bool> item in dictAnimationBoolPerItem)
			{
				Npc.playerBodyAnimator.SetBool(item.Key, item.Value);
			}
		}

		private void UpdateMoveInputVectorForOwner()
		{
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			if (!HasToMove)
			{
				lastMoveVector = Npc.moveInputVector;
				Npc.moveInputVector = Vector2.zero;
				return;
			}
			Vector2 moveInputVector = default(Vector2);
			if (Npc.isClimbingLadder)
			{
				float x = 1f;
				float y = 1f;
				if (goDownLadder)
				{
					x = -1f;
					y = -1f;
				}
				moveInputVector.x = x;
				moveInputVector.y = y;
			}
			else
			{
				Vector3 val = ((EnemyAI)LethalBotAIController).agent.steeringTarget - ((Component)Npc.thisController).transform.position;
				val.y = 0f;
				Vector3 val2 = ((Component)Npc.thisController).transform.InverseTransformDirection(((Vector3)(ref val)).normalized);
				moveInputVector.x = val2.x;
				moveInputVector.y = val2.z;
			}
			lastMoveVector = Npc.moveInputVector;
			Npc.moveInputVector = moveInputVector;
			((Vector2)(ref Npc.moveInputVector)).Normalize();
		}

		private void UpdateWalkingStateForOwner()
		{
			if (IsWalking)
			{
				if (((Vector2)(ref Npc.moveInputVector)).sqrMagnitude <= 0.19f || (Npc.inSpecialInteractAnimation && !Npc.isClimbingLadder && !Npc.inShockingMinigame))
				{
					StopAnimations();
				}
				else if (floatSprint > 0.3f && movementHinderedPrev <= 0 && !Npc.criticallyInjured && Npc.sprintMeter > 0.1f)
				{
					if (!Npc.isSprinting && Npc.sprintMeter < 0.3f)
					{
						if (!Npc.isExhausted)
						{
							Npc.isExhausted = true;
						}
					}
					else
					{
						if (Npc.isCrouching && (!SyncedEntry<bool>.op_Implicit(Plugin.Config.FollowCrouchWithPlayer) || (Object)(object)((EnemyAI)LethalBotAIController).targetPlayer == (Object)null || !LethalBotAIController.IsFollowingTargetPlayer()))
						{
							Npc.Crouch(false);
						}
						if (!Npc.isCrouching)
						{
							Npc.isSprinting = true;
						}
					}
				}
				else
				{
					Npc.isSprinting = false;
					if (Npc.sprintMeter < 0.1f)
					{
						Npc.isExhausted = true;
					}
				}
				if (Npc.isSprinting)
				{
					sprintMultiplier = Mathf.Lerp(sprintMultiplier, 2.25f, Time.deltaTime * 1f);
				}
				else
				{
					sprintMultiplier = Mathf.Lerp(sprintMultiplier, 1f, 10f * Time.deltaTime);
				}
				if (Npc.moveInputVector.y < 0.2f && Npc.moveInputVector.y > -0.2f && !Npc.inSpecialInteractAnimation)
				{
					Npc.playerBodyAnimator.SetBool("Sideways", true);
				}
				else
				{
					Npc.playerBodyAnimator.SetBool("Sideways", false);
				}
				if (Npc.enteringSpecialAnimation)
				{
					Npc.playerBodyAnimator.SetFloat("animationSpeed", 1f);
				}
				else if (Npc.moveInputVector.y < 0.5f && Npc.moveInputVector.x < 0.5f)
				{
					Npc.playerBodyAnimator.SetFloat("animationSpeed", -1f);
				}
				else
				{
					Npc.playerBodyAnimator.SetFloat("animationSpeed", 1f);
				}
			}
			else
			{
				if (Npc.enteringSpecialAnimation)
				{
					Npc.playerBodyAnimator.SetFloat("animationSpeed", 1f);
				}
				else if (Npc.isClimbingLadder)
				{
					Npc.playerBodyAnimator.SetFloat("animationSpeed", 0f);
				}
				if (((Vector2)(ref Npc.moveInputVector)).sqrMagnitude >= 0.001f && (!Npc.inSpecialInteractAnimation || Npc.isClimbingLadder || Npc.inShockingMinigame))
				{
					IsWalking = true;
				}
			}
		}

		private void UpdateEmoteStateForOwner()
		{
			if (Npc.performingEmote && (Npc.inSpecialInteractAnimation || Npc.isPlayerDead || Npc.isCrouching || Npc.isClimbingLadder || Npc.isGrabbingObjectAnimation || Npc.inTerminalMenu || Npc.isTypingChat))
			{
				Npc.performingEmote = false;
				LethalBotAIController.SyncStopPerformingEmote();
			}
		}

		private void UpdateSinkingStateForOwner()
		{
			//IL_012f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0139: Unknown result type (might be due to invalid IL or missing references)
			//IL_013f: Unknown result type (might be due to invalid IL or missing references)
			Npc.playerBodyAnimator.SetBool("hinderedMovement", Npc.isMovementHindered > 0);
			if (Npc.sourcesCausingSinking == 0)
			{
				if (Npc.isSinking)
				{
					Npc.isSinking = false;
					LethalBotAIController.SyncChangeSinkingState(startSinking: false);
				}
				return;
			}
			if (Npc.isSinking)
			{
				Npc.GetCurrentMaterialStandingOn(false);
				if (!CheckConditionsForSinkingInQuicksandLethalBot())
				{
					Npc.isSinking = false;
					LethalBotAIController.SyncChangeSinkingState(startSinking: false);
				}
			}
			else if (!Npc.isSinking && CheckConditionsForSinkingInQuicksandLethalBot())
			{
				Npc.isSinking = true;
				LethalBotAIController.SyncChangeSinkingState(startSinking: true, Npc.sinkingSpeedMultiplier, Npc.statusEffectAudioIndex);
			}
			if (Npc.sinkingValue >= 1f)
			{
				Plugin.LogDebug($"SyncKillLethalBot from sinkingValue for LOCAL client #{((NetworkBehaviour)Npc).NetworkManager.LocalClientId}, lethalBot object: Bot #{Npc.playerClientId}");
				Npc.KillPlayer(Vector3.zero, false, (CauseOfDeath)5, 0, default(Vector3), false);
			}
			else if (Npc.sinkingValue > 0.5f)
			{
				Npc.Crouch(false);
			}
		}

		private void UpdateCenterAndHeightForOwner()
		{
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			//IL_011a: Unknown result type (might be due to invalid IL or missing references)
			//IL_012a: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0050: 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_006a: Unknown result type (might be due to invalid IL or missing references)
			if (Npc.isCrouching)
			{
				Npc.thisController.center = Vector3.Lerp(Npc.thisController.center, new Vector3(Npc.thisController.center.x, 0.72f, Npc.thisController.center.z), 8f * Time.deltaTime);
				Npc.thisController.height = Mathf.Lerp(Npc.thisController.height, 1.5f, 8f * Time.deltaTime);
			}
			else
			{
				CrouchMeter = Mathf.Max(CrouchMeter - Time.deltaTime * 2f, 0f);
				Npc.thisController.center = Vector3.Lerp(Npc.thisController.center, new Vector3(Npc.thisController.center.x, 1.28f, Npc.thisController.center.z), 8f * Time.deltaTime);
				Npc.thisController.height = Mathf.Lerp(Npc.thisController.height, 2.5f, 8f * Time.deltaTime);
			}
			((EnemyAI)LethalBotAIController).agent.radius = Npc.thisController.radius;
		}

		private void UpdateJetPackControlsForOwner()
		{
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_015d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0162: Unknown result type (might be due to invalid IL or missing references)
			//IL_0188: Unknown result type (might be due to invalid IL or missing references)
			//IL_0198: Unknown result type (might be due to invalid IL or missing references)
			//IL_0125: Unknown result type (might be due to invalid IL or missing references)
			//IL_012a: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_014c: Unknown result type (might be due to invalid IL or missing references)
			//IL_033e: Unknown result type (might be due to invalid IL or missing references)
			//IL_034e: Unknown result type (might be due to invalid IL or missing references)
			//IL_035e: Unknown result type (might be due to invalid IL or missing references)
			//IL_020d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0212: Unknown result type (might be due to invalid IL or missing references)
			//IL_02cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0300: Unknown result type (might be due to invalid IL or missing references)
			//IL_0322: Unknown result type (might be due to invalid IL or missing references)
			if (disabledJetpackControlsThisFrame)
			{
				disabledJetpackControlsThisFrame = false;
			}
			if (!Npc.jetpackControls)
			{
				return;
			}
			if (Npc.disablingJetpackControls && IsTouchingGround)
			{
				disabledJetpackControlsThisFrame = true;
				LethalBotAIController.SyncDisableJetpackMode();
			}
			else
			{
				if (IsTouchingGround)
				{
					return;
				}
				if (!StartedJetpackControls)
				{
					StartedJetpackControls = true;
					Npc.jetpackTurnCompass.rotation = ((Component)Npc).transform.rotation;
				}
				Npc.thisController.radius = Mathf.Lerp(Npc.thisController.radius, 1.25f, 10f * Time.deltaTime);
				Quaternion rotation = Npc.jetpackTurnCompass.rotation;
				Npc.jetpackTurnCompass.Rotate(new Vector3(0f, 0f, 0f - Npc.moveInputVector.x) * (180f * Time.deltaTime), (Space)1);
				if (Npc.maxJetpackAngle != -1f && Vector3.Angle(Npc.jetpackTurnCompass.up, Vector3.up) > Npc.maxJetpackAngle)
				{
					Npc.jetpackTurnCompass.rotation = rotation;
				}
				rotation = Npc.jetpackTurnCompass.rotation;
				Npc.jetpackTurnCompass.Rotate(new Vector3(Npc.moveInputVector.y, 0f, 0f) * (180f * Time.deltaTime), (Space)1);
				if (Npc.maxJetpackAngle != -1f && Vector3.Angle(Npc.jetpackTurnCompass.up, Vector3.up) > Npc.maxJetpackAngle)
				{
					Npc.jetpackTurnCompass.rotation = rotation;
				}
				if (Npc.jetpackRandomIntensity != -1f)
				{
					rotation = Npc.jetpackTurnCompass.rotation;
					Vector3 val = default(Vector3);
					((Vector3)(ref val))..ctor(Mathf.Clamp(Random.Range(0f - Npc.jetpackRandomIntensity, Npc.jetpackRandomIntensity), 0f - Npc.maxJetpackAngle, Npc.maxJetpackAngle), Mathf.Clamp(Random.Range(0f - Npc.jetpackRandomIntensity, Npc.jetpackRandomIntensity), 0f - Npc.maxJetpackAngle, Npc.maxJetpackAngle), Mathf.Clamp(Random.Range(0f - Npc.jetpackRandomIntensity, Npc.jetpackRandomIntensity), 0f - Npc.maxJetpackAngle, Npc.maxJetpackAngle));
					Npc.jetpackTurnCompass.Rotate(val * Time.deltaTime, (Space)1);
					if (Npc.maxJetpackAngle != -1f && Vector3.Angle(Npc.jetpackTurnCompass.up, Vector3.up) > Npc.maxJetpackAngle)
					{
						Npc.jetpackTurnCompass.rotation = rotation;
					}
				}
				((Component)Npc).transform.rotation = Quaternion.Slerp(((Component)Npc).transform.rotation, Npc.jetpackTurnCompass.rotation, 8f * Time.deltaTime);
			}
		}

		private void UpdateMoveControllerForOwner()
		{
			//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_0167: Unknown result type (might be due to invalid IL or missing references)
			//IL_016c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0266: Unknown result type (might be due to invalid IL or missing references)
			//IL_0276: Unknown result type (might be due to invalid IL or missing references)
			//IL_028b: Unknown result type (might be due to invalid IL or missing references)
			//IL_029b: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0302: Unknown result type (might be due to invalid IL or missing references)
			//IL_0307: Unknown result type (might be due to invalid IL or missing references)
			//IL_030c: Unknown result type (might be due to invalid IL or missing references)
			//IL_030d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0314: Unknown result type (might be due to invalid IL or missing references)
			//IL_0319: Unknown result type (might be due to invalid IL or missing references)
			//IL_031e: Unknown result type (might be due to invalid IL or missing references)
			//IL_037f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0384: Unknown result type (might be due to invalid IL or missing references)
			//IL_038a: Unknown result type (might be due to invalid IL or missing references)
			//IL_038b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0336: Unknown result type (might be due to invalid IL or missing references)
			//IL_033d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0342: Unknown result type (might be due to invalid IL or missing references)
			//IL_0347: Unknown result type (might be due to invalid IL or missing references)
			//IL_0354: Unknown result type (might be due to invalid IL or missing references)
			//IL_0359: Unknown result type (might be due to invalid IL or missing references)
			//IL_0369: Unknown result type (might be due to invalid IL or missing references)
			//IL_036e: Unknown result type (might be due to invalid IL or missing references)
			StartOfRound instance = StartOfRound.Instance;
			if (Npc.isFreeCamera)
			{
				Npc.moveInputVector = Vector2.zero;
			}
			float num = Npc.movementSpeed / Npc.carryWeight;
			if (Npc.sinkingValue > 0.73f)
			{
				num = 0f;
			}
			else
			{
				if (Npc.isCrouching)
				{
					num /= 1.5f;
				}
				else if (Npc.criticallyInjured && !Npc.isCrouching)
				{
					num *= LimpMultiplier;
				}
				if (Npc.isSpeedCheating)
				{
					num *= 15f;
				}
				if (movementHinderedPrev > 0)
				{
					num /= 2f * Npc.hinderedMultiplier;
				}
				if (Npc.drunkness > 0f)
				{
					num *= instance.drunknessSpeedEffect.Evaluate(Npc.drunkness) / 5f + 1f;
				}
				if (Npc.poison > 0f)
				{
					num *= 0.75f;
				}
				if (!Npc.isCrouching && CrouchMeter > 1.2f)
				{
					num *= 0.5f;
				}
			}
			if (Npc.isTypingChat || (Npc.jetpackControls && !IsTouchingGround) || instance.suckingPlayersOutOfShip)
			{
				Npc.moveInputVector = Vector2.zero;
			}
			float num2 = 1f;
			num2 = ((IsFallingFromJump || isFallingNoJump) ? 1.33f : ((Npc.drunkness > 0.3f) ? Mathf.Clamp(Mathf.Abs(Npc.drunkness - 2.25f), 0.3f, 2.5f) : ((Npc.poison > 0.3f) ? Mathf.Clamp(Mathf.Abs(Npc.poison - 2.25f), 0.3f, 2.5f) : ((!Npc.isCrouching && CrouchMeter > 1f) ? 15f : ((!Npc.isSprinting) ? (10f / Npc.carryWeight) : (5f / (Npc.carryWeight * 1.5f)))))));
			walkForce = Vector3.MoveTowards(walkForce, ((Component)Npc).transform.right * Npc.moveInputVector.x + ((Component)Npc).transform.forward * Npc.moveInputVector.y, num2 * Time.deltaTime);
			Vector3 val = walkForce * num * sprintMultiplier + new Vector3(0f, Npc.fallValue, 0f) + NearEntitiesPushVector;
			val += Npc.externalForces;
			if (((Vector3)(ref Npc.externalForceAutoFade)).magnitude > 0.05f)
			{
				val += Npc.externalForceAutoFade;
				Npc.externalForceAutoFade = Vector3.Lerp(Npc.externalForceAutoFade, Vector3.zero, 2f * Time.deltaTime);
			}
			PlayerSlidingTimer = 0f;
			NearEntitiesPushVector = Vector3.zero;
			MoveVector = val;
		}

		private void UpdateFallValuesForOwner()
		{
			if (Npc.inSpecialInteractAnimation && !Npc.inShockingMinigame)
			{
				return;
			}
			if (!IsTouchingGround)
			{
				if (Npc.jetpackControls && !Npc.disablingJetpackControls)
				{
					Npc.fallValue = Mathf.MoveTowards(Npc.fallValue, Npc.jetpackCounteractiveForce, 9f * Time.deltaTime);
					Npc.fallValueUncapped = -8f;
				}
				else
				{
					Npc.fallValue = Mathf.Clamp(Npc.fallValue - 38f * Time.deltaTime, -150f, Npc.jumpForce);
					if (Mathf.Abs(Npc.externalForceAutoFade.y) - Mathf.Abs(Npc.fallValue) < 5f)
					{
						if (Npc.disablingJetpackControls)
						{
							PlayerControllerB npc = Npc;
							npc.fallValueUncapped -= 26f * Time.deltaTime;
						}
						else
						{
							PlayerControllerB npc2 = Npc;
							npc2.fallValueUncapped -= 38f * Time.deltaTime;
						}
					}
				}
				if (!IsJumping && !IsFallingFromJump)
				{
					if (!isFallingNoJump)
					{
						isFallingNoJump = true;
						Npc.fallValue = -7f;
						Npc.fallValueUncapped = -7f;
					}
					else if (Npc.fallValue < -20f)
					{
						Npc.isCrouching = false;
						Npc.playerBodyAnimator.SetBool("crouching", false);
						Npc.playerBodyAnimator.SetBool("FallNoJump", true);
					}
				}
				if (Npc.fallValueUncapped < -35f)
				{
					Npc.takingFallDamage = true;
				}
				return;
			}
			movementHinderedPrev = Npc.isMovementHindered;
			if (!IsJumping && isFallingNoJump)
			{
				isFallingNoJump = false;
				if (!Npc.isCrouching && Npc.fallValue < -9f)
				{
					Npc.playerBodyAnimator.SetTrigger("ShortFallLanding");
				}
				PlayerControllerBPatch.PlayerHitGroundEffects_ReversePatch(Npc);
			}
			Npc.playerBodyAnimator.SetBool("FallNoJump", false);
		}

		private void UpdateJetPackMoveValuesForOwner()
		{
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0327: Unknown result type (might be due to invalid IL or missing references)
			//IL_032c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0245: Unknown result type (might be due to invalid IL or missing references)
			//IL_024f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_028c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0296: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ed: Unknown result type (might be due to invalid IL or missing references)
			StartOfRound instance = StartOfRound.Instance;
			if (Npc.jetpackControls || Npc.disablingJetpackControls)
			{
				if (!TeleportingThisFrame && !Npc.inSpecialInteractAnimation && !Npc.enteringSpecialAnimation && !Npc.isClimbingLadder && (instance.timeSinceRoundStarted > 1f || (Object)(object)instance.testRoom != (Object)null))
				{
					Vector3 velocity = Npc.thisController.velocity;
					float magnitude = ((Vector3)(ref velocity)).magnitude;
					if (Npc.getAverageVelocityInterval <= 0f)
					{
						Npc.getAverageVelocityInterval = 0.04f;
						PlayerControllerB npc = Npc;
						npc.velocityAverageCount++;
						if (Npc.velocityAverageCount > Npc.velocityMovingAverageLength)
						{
							PlayerControllerB npc2 = Npc;
							npc2.averageVelocity += (magnitude - Npc.averageVelocity) / (float)(Npc.velocityMovingAverageLength + 1);
						}
						else
						{
							PlayerControllerB npc3 = Npc;
							npc3.averageVelocity += magnitude;
							if (Npc.velocityAverageCount == Npc.velocityMovingAverageLength)
							{
								PlayerControllerB npc4 = Npc;
								npc4.averageVelocity /= (float)Npc.velocityAverageCount;
							}
						}
					}
					else
					{
						PlayerControllerB npc5 = Npc;
						npc5.getAverageVelocityInterval -= Time.deltaTime;
					}
					if (TimeSinceTakingGravityDamage > 0.6f && Npc.velocityAverageCount > 4)
					{
						float num = Vector3.Angle(((Component)Npc).transform.up, Vector3.up);
						if (Physics.CheckSphere(((Component)Npc.gameplayCamera).transform.position, 0.5f, instance.collidersAndRoomMaskAndDefault, (QueryTriggerInteraction)1) || (num > 65f && Physics.CheckSphere(Npc.lowerSpine.position, 0.5f, instance.collidersAndRoomMaskAndDefault, (QueryTriggerInteraction)1)))
						{
							if (Npc.averageVelocity > 17f)
							{
								TimeSinceTakingGravityDamage = 0f;
								Npc.DamagePlayer(Mathf.Clamp(85, 20, 100), true, true, (CauseOfDeath)2, 0, true, Vector3.ClampMagnitude(Npc.velocityLastFrame, 50f));
							}
							else if (Npc.averageVelocity > 9f)
							{
								Npc.DamagePlayer(Mathf.Clamp(30, 20, 100), true, true, (CauseOfDeath)2, 0, true, Vector3.ClampMagnitude(Npc.velocityLastFrame, 50f));
								TimeSinceTakingGravityDamage = 0.35f;
							}
							else if (num > 60f && Npc.averageVelocity > 6f)
							{
								Npc.DamagePlayer(Mathf.Clamp(30, 20, 100), true, true, (CauseOfDeath)2, 0, true, Vector3.ClampMagnitude(Npc.velocityLastFrame, 50f));
								TimeSinceTakingGravityDamage = 0f;
							}
						}
					}
					else
					{
						TimeSinceTakingGravityDamage += Time.deltaTime;
					}
					Npc.velocityLastFrame = Npc.thisController.velocity;
					PreviousFrameDeltaTime = Time.deltaTime;
				}
				else
				{
					TeleportingThisFrame = false;
				}
			}
			else
			{
				Npc.averageVelocity = 0f;
				Npc.velocityAverageCount = 0;
				TimeSinceTakingGravityDamage = 0f;
			}
		}

		private void UpdateMoveWhenClimbingLadder()
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: 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_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: Unknown result type (might be due to invalid IL or missing references)
			//IL_0118: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = Npc.thisPlayerBody.up;
			Vector3 val2 = ((Component)Npc.gameplayCamera).transform.position + Npc.thisPlayerBody.up * 0.07f;
			Vector3 val3 = Npc.externalForces + Npc.externalForceAutoFade;
			if (((Vector3)(ref val3)).sqrMagnitude > 64f)
			{
				Npc.CancelSpecialTriggerAnimations();
			}
			Npc.externalForces = Vector3.zero;
			Npc.externalForceAutoFade = Vector3.Lerp(Npc.externalForceAutoFade, Vector3.zero, 5f * Time.deltaTime);
			if (goDownLadder)
			{
				val = -Npc.thisPlayerBody.up;
				val2 = ((Component)Npc).transform.position;
			}
			Transform transform = ((Component)Npc.thisPlayerBody).transform;
			transform.position += val * (0.9f * Npc.climbSpeed * Time.deltaTime);
		}

		private void UpdateAnimationsForOwner()
		{
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			if (Npc.playerBodyAnimator.GetBool("Walking") != IsWalking)
			{
				Npc.playerBodyAnimator.SetBool("Walking", IsWalking);
			}
			if (Npc.playerBodyAnimator.GetBool("Sprinting") != Npc.isSprinting)
			{
				Npc.playerBodyAnimator.SetBool("Sprinting", Npc.isSprinting);
			}
			for (int i = 0; i < Npc.playerBodyAnimator.layerCount; i++)
			{
				int[] array = animationHashLayers;
				int num = i;
				AnimatorStateInfo currentAnimatorStateInfo = Npc.playerBodyAnimator.GetCurrentAnimatorStateInfo(i);
				array[num] = ((AnimatorStateInfo)(ref currentAnimatorStateInfo)).fullPathHash;
			}
			if ((Object)(object)NetworkManager.Singleton != (Object)null && Npc.playersManager.connectedPlayersAmount > 0)
			{
				UpdateLethalBotAnimationsToOtherClients(animationHashLayers);
			}
		}

		private void UpdateSyncPositionAndRotationForNotOwner()
		{
			//IL_0198: Unknown result type (might be due to invalid IL or missing references)
			//IL_0126: Unknown result type (might be due to invalid IL or missing references)
			//IL_014b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			if (!Npc.isPlayerDead && Npc.isPlayerControlled)
			{
				if (!Npc.disableSyncInAnimation)
				{
					if (Npc.snapToServerPosition)
					{
						((Component)Npc).transform.localPosition = Vector3.Lerp(((Component)Npc).transform.localPosition, Npc.serverPlayerPosition, 16f * Time.deltaTime);
					}
					else
					{
						float num = 8f;
						if (Npc.jetpackControls)
						{
							num = 15f;
						}
						float num2 = Mathf.Clamp(num * Vector3.Distance(((Component)Npc).transform.localPosition, Npc.serverPlayerPosition), 0.9f, 300f);
						((Component)Npc).transform.localPosition = Vector3.MoveTowards(((Component)Npc).transform.localPosition, Npc.serverPlayerPosition, num2 * Time.deltaTime);
					}
				}
				UpdateTurnBodyTowardsDirection();
				UpdateLookAt();
				Npc.playerEye.position = ((Component)Npc.gameplayCamera).transform.position;
				Npc.playerEye.rotation = ((Component)Npc.gameplayCamera).transform.rotation;
			}
			else if ((Npc.isPlayerDead || !Npc.isPlayerControlled) && Npc.setPositionOfDeadPlayer)
			{
				((Component)Npc).transform.position = Npc.playersManager.notSpawnedPosition.position;
			}
		}

		private void UpdateLethalBotAnimationsLocalForNotOwner(int[] animationsStateHash)
		{
			updatePlayerAnimationsInterval += Time.deltaTime;
			if (!Npc.inSpecialInteractAnimation && !(updatePlayerAnimationsInterval > 0.14f))
			{
				return;
			}
			updatePlayerAnimationsInterval = 0f;
			currentAnimationSpeed = Npc.playerBodyAnimator.GetFloat("animationSpeed");
			for (int i = 0; i < animationsStateHash.Length; i++)
			{
				currentAnimationStateHash[i] = animationsStateHash[i];
				if (previousAnimationStateHash[i] != currentAnimationStateHash[i])
				{
					previousAnimationStateHash[i] = currentAnimationStateHash[i];
					previousAnimationSpeed = currentAnimationSpeed;
					ApplyUpdateLethalBotAnimationsNotOwner(currentAnimationStateHash[i], currentAnimationSpeed);
					return;
				}
			}
			if (previousAnimationSpeed != currentAnimationSpeed)
			{
				previousAnimationSpeed = currentAnimationSpeed;
				ApplyUpdateLethalBotAnimationsNotOwner(0, currentAnimationSpeed);
			}
		}

		private void UpdateInSpecialInteractAnimationEffect()
		{
			//IL_01cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0158: Unknown result type (might be due to invalid IL or missing references)
			//IL_0172: Unknown result type (might be due to invalid IL or missing references)
			//IL_017c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			if (!Npc.inSpecialInteractAnimation)
			{
				if (Npc.playingQuickSpecialAnimation)
				{
					Npc.specialAnimationWeight = 1f;
				}
				else
				{
					Npc.specialAnimationWeight = Mathf.Lerp(Npc.specialAnimationWeight, 0f, Time.deltaTime * 12f);
				}
				if (!Npc.localArmsMatchCamera)
				{
					Npc.localArmsTransform.position = Npc.playerModelArmsMetarig.position + Npc.playerModelArmsMetarig.forward * -0.445f;
					Npc.playerModelArmsMetarig.rotation = Quaternion.Lerp(Npc.playerModelArmsMetarig.rotation, Npc.localArmsRotationTarget.rotation, 15f * Time.deltaTime);
				}
			}
			else
			{
				if ((!Npc.isClimbingLadder && !Npc.inShockingMinigame) || Npc.freeRotationInInteractAnimation)
				{
					CameraUp = Mathf.Lerp(CameraUp, 0f, 5f * Time.deltaTime);
					((Component)Npc.gameplayCamera).transform.localEulerAngles = new Vector3(CameraUp, ((Component)Npc.gameplayCamera).transform.localEulerAngles.y, ((Component)Npc.gameplayCamera).transform.localEulerAngles.z);
				}
				Npc.specialAnimationWeight = Mathf.Lerp(Npc.specialAnimationWeight, 1f, Time.deltaTime * 20f);
				Npc.playerModelArmsMetarig.localEulerAngles = new Vector3(-90f, 0f, 0f);
			}
		}

		private void UpdateEmoteEffects()
		{
			if (Npc.doingUpperBodyEmote > 0f)
			{
				PlayerControllerB npc = Npc;
				npc.doingUpperBodyEmote -= Time.deltaTime;
			}
			if (Npc.performingEmote)
			{
				Npc.emoteLayerWeight = Mathf.Lerp(Npc.emoteLayerWeight, 1f, 10f * Time.deltaTime);
			}
			else
			{
				Npc.emoteLayerWeight = Mathf.Lerp(Npc.emoteLayerWeight, 0f, 10f * Time.deltaTime);
			}
			Npc.playerBodyAnimator.SetLayerWeight(Npc.playerBodyAnimator.GetLayerIndex("EmotesNoArms"), Npc.emoteLayerWeight);
		}

		private void UpdateSinkingEffects()
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			StartOfRound instance = StartOfRound.Instance;
			Npc.meshContainer.position = Vector3.Lerp(((Component)Npc).transform.position, ((Component)Npc).transform.position - Vector3.up * 2.8f, instance.playerSinkingCurve.Evaluate(Npc.sinkingValue));
			if (Npc.isSinking && !Npc.inSpecialInteractAnimation && (Object)(object)Npc.inAnimationWithEnemy == (Object)null)
			{
				Npc.sinkingValue = Mathf.Clamp(Npc.sinkingValue + Time.deltaTime * Npc.sinkingSpeedMultiplier, 0f, 1f);
			}
			else
			{
				Npc.sinkingValue = Mathf.Clamp(Npc.sinkingValue - Time.deltaTime * 0.75f, 0f, 1f);
			}
			if (Npc.sinkingValue > 0.73f || Npc.isUnderwater)
			{
				if (!wasUnderwaterLastFrame)
				{
					wasUnderwaterLastFrame = true;
					Npc.waterBubblesAudio.Play();
				}
				Npc.voiceMuffledByEnemy = true;
				Npc.statusEffectAudio.volume = Mathf.Lerp(Npc.statusEffectAudio.volume, 0f, 4f * Time.deltaTime);
				OccludeAudioComponent.overridingLowPass = true;
				OccludeAudioComponent.lowPassOverride = 600f;
				Npc.waterBubblesAudio.volume = Mathf.Clamp(LethalBotAIController.LethalBotIdentity.Voice.GetVoiceAmplitude() * 120f, 0f, 1f);
			}
			else if (wasUnderwaterLastFrame)
			{
				Npc.waterBubblesAudio.Stop();
				wasUnderwaterLastFrame = false;
				Npc.voiceMuffledByEnemy = false;
			}
			else
			{
				Npc.statusEffectAudio.volume = Mathf.Lerp(Npc.statusEffectAudio.volume, 1f, 4f * Time.deltaTime);
			}
		}

		private void UpdateActiveAudioReverbFilter()
		{
			GameNetworkManager instance = GameNetworkManager.Instance;
			StartOfRound instance2 = StartOfRound.Instance;
			if ((Object)(object)Npc.activeAudioReverbFilter == (Object)null)
			{
				Npc.activeAudioReverbFilter = ((Component)Npc.activeAudioListener).GetComponent<AudioReverbFilter>();
				((Behaviour)Npc.activeAudioReverbFilter).enabled = true;
			}
			if ((Object)(object)Npc.reverbPreset != (Object)null && (Object)(object)instance != (Object)null && (Object)(object)instance.localPlayerController != (Object)null && (((Object)(object)instance.localPlayerController == (Object)(object)Npc && (!Npc.isPlayerDead || instance2.overrideSpectateCamera)) || ((Object)(object)instance.localPlayerController.spectatedPlayerScript == (Object)(object)Npc && !instance2.overrideSpectateCamera)))
			{
				AudioReverbFilter activeAudioReverbFilter = Npc.activeAudioReverbFilter;
				ReverbPreset reverbPreset = Npc.reverbPreset;
				activeAudioReverbFilter.dryLevel = Mathf.Lerp(activeAudioReverbFilter.dryLevel, reverbPreset.dryLevel, 15f * Time.deltaTime);
				activeAudioReverbFilter.roomLF = Mathf.Lerp(activeAudioReverbFilter.roomLF, reverbPreset.lowFreq, 15f * Time.deltaTime);
				activeAudioReverbFilter.roomLF = Mathf.Lerp(activeAudioReverbFilter.roomHF, reverbPreset.highFreq, 15f * Time.deltaTime);
				activeAudioReverbFilter.decayTime = Mathf.Lerp(activeAudioReverbFilter.decayTime, reverbPreset.decayTime, 15f * Time.deltaTime);
				activeAudioReverbFilter.room = Mathf.Lerp(activeAudioReverbFilter.room, reverbPreset.room, 15f * Time.deltaTime);
				SoundManager.Instance.SetEchoFilter(reverbPreset.hasEcho);
			}
		}

		private void UpdateAnimationUpperBody()
		{
			int layerIndex = Npc.playerBodyAnimator.GetLayerIndex("HoldingItemsRightHand");
			int layerIndex2 = Npc.playerBodyAnimator.GetLayerIndex("HoldingItemsBothHands");
			if (Npc.isHoldingObject || Npc.isGrabbingObjectAnimation || Npc.inShockingMinigame)
			{
				UpperBodyAnimationsWeight = Mathf.Lerp(UpperBodyAnimationsWeight, 1f, 25f * Time.deltaTime);
				Npc.playerBodyAnimator.SetLayerWeight(layerIndex, UpperBodyAnimationsWeight);
				if (Npc.twoHandedAnimation || Npc.inShockingMinigame)
				{
					Npc.playerBodyAnimator.SetLayerWeight(layerIndex2, UpperBodyAnimationsWeight);
				}
				else
				{
					Npc.playerBodyAnimator.SetLayerWeight(layerIndex2, Mathf.Abs(UpperBodyAnimationsWeight - 1f));
				}
			}
			else
			{
				UpperBodyAnimationsWeight = Mathf.Lerp(UpperBodyAnimationsWeight, 0f, 25f * Time.deltaTime);
				Npc.playerBodyAnimator.SetLayerWeight(layerIndex, UpperBodyAnimationsWeight);
				Npc.playerBodyAnimator.SetLayerWeight(layerIndex2, UpperBodyAnimationsWeight);
			}
			Npc.playerBodyAnimator.SetLayerWeight(Npc.playerBodyAnimator.GetLayerIndex("SpecialAnimations"), Npc.specialAnimationWeight);
			if (Npc.inSpecialInteractAnimation && !Npc.inShockingMinigame)
			{
				((RigConstraint<MultiRotationConstraintJob, MultiRotationConstraintData, MultiRotationConstraintJobBinder<MultiRotationConstraintData>>)(object)Npc.cameraLookRig1).weight = Mathf.Lerp(((RigConstraint<MultiRotationConstraintJob, MultiRotationConstraintData, MultiRotationConstraintJobBinder<MultiRotationConstraintData>>)(object)Npc.cameraLookRig1).weight, 0f, Time.deltaTime * 25f);
				((RigConstraint<MultiRotationConstraintJob, MultiRotationConstraintData, MultiRotationConstraintJobBinder<MultiRotationConstraintData>>)(object)Npc.cameraLookRig2).weight = Mathf.Lerp(((RigConstraint<MultiRotationConstraintJob, MultiRotationConstraintData, MultiRotationConstraintJobBinder<MultiRotationConstraintData>>)(object)Npc.cameraLookRig1).weight, 0f, Time.deltaTime * 25f);
			}
			else
			{
				((RigConstraint<MultiRotationConstraintJob, MultiRotationConstraintData, MultiRotationConstraintJobBinder<MultiRotationConstraintData>>)(object)Npc.cameraLookRig1).weight = 0.45f;
				((RigConstraint<MultiRotationConstraintJob, MultiRotationConstraintData, MultiRotationConstraintJobBinder<MultiRotationConstraintData>>)(object)Npc.cameraLookRig2).weight = 1f;
			}
			if (Npc.isExhausted)
			{
				exhaustionEffectLerp = Mathf.Lerp(exhaustionEffectLerp, 1f, 10f * Time.deltaTime);
			}
			else
			{
				exhaustionEffectLerp = Mathf.Lerp(exhaustionEffectLerp, 0f, 10f * Time.deltaTime);
			}
			Npc.playerBodyAnimator.SetFloat("tiredAmount", exhaustionEffectLerp);
		}

		private void UpdateBleedEffects()
		{
			if (Npc.bleedingHeavily && BloodDropTimer >= 0f)
			{
				BloodDropTimer -= Time.deltaTime;
			}
		}

		private void UpdateStaminaTimer()
		{
			if (Npc.isExhausted)
			{
				WaitForFullStamina = true;
			}
			else if (WaitForFullStamina && Npc.sprintMeter >= 0.8f)
			{
				WaitForFullStamina = false;
			}
		}

		private void UpdateDrunknessAndPoisonEffects()
		{
			if (Npc.isPlayerDead)
			{
				Npc.drunkness = 0f;
				Npc.drunknessInertia = 0f;
				Npc.poison = 0f;
				return;
			}
			if (Npc.slimeOnFace >= 0f)
			{
				PlayerControllerB npc = Npc;
				npc.slimeOnFace -= Time.deltaTime;
				Npc.slimeOnFaceDecals[0].fadeFactor = Mathf.Min(Npc.slimeOnFace, 1f);
				Npc.slimeOnFaceDecals[1].fadeFactor = Mathf.Min(Npc.slimeOnFace, 1f);
			}
			Npc.drunkness = Mathf.Clamp(Npc.drunkness + Time.deltaTime / 12f * Npc.drunknessSpeed * Npc.drunknessInertia, 0f, 1f);
			if (!Npc.increasingDrunknessThisFrame)
			{
				if (Npc.drunkness > 0f)
				{
					Npc.drunknessInertia = Mathf.Clamp(Npc.drunknessInertia - Time.deltaTime / 3f * Npc.drunknessSpeed / Mathf.Clamp(Mathf.Abs(Npc.drunknessInertia), 0.2f, 1f), -2.5f, 2.5f);
				}
				else
				{
					Npc.drunknessInertia = 0f;
				}
			}
			else
			{
				Npc.increasingDrunknessThisFrame = false;
			}
			if (!Npc.overridePoisonValue)
			{
				Npc.poison = Mathf.Clamp(Npc.poison + Time.deltaTime / 12f * Npc.poisonSpeed * Npc.poisonInertia, 0f, 1f);
			}
			if (!Npc.increasingPoisonThisFrame)
			{
				if (Npc.poison > 0f)
				{
					Npc.poisonInertia = Mathf.Clamp(Npc.poisonInertia - Time.deltaTime / 3f * Npc.poisonSpeed / Mathf.Clamp(Mathf.Abs(Npc.poisonInertia), 0.2f, 1f), -2.5f, 2.5f);
				}
				else
				{
					Npc.poisonInertia = 0f;
				}
			}
			else
			{
				Npc.increasingPoisonThisFrame = false;
			}
			float num = StartOfRound.Instance.drunknessSideEffect.Evaluate(Npc.drunkness);
			LethalBotVoice voice = LethalBotAIController.LethalBotIdentity.Voice;
			float voicePitch = voice.VoicePitch;
			if (num > 0.15f)
			{
				SoundManager.Instance.playerVoicePitchTargets[Npc.playerClientId] = voicePitch + num;
			}
			else
			{
				SoundManager.Instance.playerVoicePitchTargets[Npc.playerClientId] = voicePitch;
			}
		}

		private void UpdateLineOfSightCube()
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			RaycastHit val = default(RaycastHit);
			if (Physics.Raycast(Npc.lineOfSightCube.position, Npc.lineOfSightCube.forward, ref val, 10f, Npc.playersManager.collidersAndRoomMask, (QueryTriggerInteraction)1))
			{
				Npc.lineOfSightCube.localScale = new Vector3(1.5f, 1.5f, ((RaycastHit)(ref val)).distance);
			}
			else
			{
				Npc.lineOfSightCube.localScale = new Vector3(1.5f, 1.5f, 10f);
			}
		}

		private void UpdateLethalBotAnimationsToOtherClients(int[] animationsStateHash)
		{
			updatePlayerAnimationsInterval += Time.deltaTime;
			if (!Npc.inSpecialInteractAnimation && !(updatePlayerAnimationsInterval > 0.14f))
			{
				return;
			}
			updatePlayerAnimationsInterval = 0f;
			currentAnimationSpeed = Npc.playerBodyAnimator.GetFloat("animationSpeed");
			for (int i = 0; i < animationsStateHash.Length; i++)
			{
				currentAnimationStateHash[i] = animationsStateHash[i];
				if (previousAnimationStateHash[i] != currentAnimationStateHash[i])
				{
					previousAnimationStateHash[i] = currentAnimationStateHash[i];
					previousAnimationSpeed = currentAnimationSpeed;
					LethalBotAIController.UpdateLethalBotAnimationServerRpc(currentAnimationStateHash[i], currentAnimationSpeed);
					return;
				}
			}
			if (previousAnimationSpeed != currentAnimationSpeed)
			{
				previousAnimationSpeed = currentAnimationSpeed;
				LethalBotAIController.UpdateLethalBotAnimationServerRpc(0, currentAnimationSpeed);
			}
		}

		public void ApplyUpdateLethalBotAnimationsNotOwner(int animationState, float animationSpeed)
		{
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			if (Npc.playerBodyAnimator.GetFloat("animationSpeed") != animationSpeed)
			{
				Npc.playerBodyAnimator.SetFloat("animationSpeed", animationSpeed);
			}
			if (animationState == 0)
			{
				return;
			}
			AnimatorStateInfo currentAnimatorStateInfo = Npc.playerBodyAnimator.GetCurrentAnimatorStateInfo(0);
			if (((AnimatorStateInfo)(ref currentAnimatorStateInfo)).fullPathHash == animationState)
			{
				return;
			}
			for (int i = 0; i < Npc.playerBodyAnimator.layerCount; i++)
			{
				if (Npc.playerBodyAnimator.HasState(i, animationState))
				{
					animationHashLayers[i] = animationState;
					Npc.playerBodyAnimator.CrossFadeInFixedTime(animationState, 0.1f);
					break;
				}
			}
		}

		public void StopAnimations()
		{
			IsWalking = false;
			Npc.isSprinting = false;
			Npc.playerBodyAnimator.SetBool("Walking", false);
			Npc.playerBodyAnimator.SetBool("Sprinting", false);
			Npc.playerBodyAnimator.SetBool("Sideways", false);
		}

		public void PlayFootstep(bool isServer)
		{
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: 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_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0130: Unknown result type (might be due to invalid IL or missing references)
			//IL_0135: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_011e: Unknown result type (might be due to invalid IL or missing references)
			if (!Npc.isClimbingLadder && !Npc.inSpecialInteractAnimation && !Npc.isCrouching && ((isServer && !((NetworkBehaviour)LethalBotAIController).IsOwner && Npc.isPlayerControlled) || (!isServer && ((NetworkBehaviour)LethalBotAIController).IsOwner && Npc.isPlayerControlled)))
			{
				bool noiseIsInsideClosedShip = Npc.isInHangarShipRoom && Npc.playersManager.hangarDoorsClosed;
				if (Npc.isSprinting)
				{
					PlayAudibleNoiseLethalBot(((Component)Npc).transform.position, 22f, 0.6f, 0, noiseIsInsideClosedShip, 6);
				}
				else
				{
					PlayAudibleNoiseLethalBot(((Component)Npc).transform.position, 17f, 0.4f, 0, noiseIsInsideClosedShip, 6);
				}
				PlayerControllerB localPlayerController = StartOfRound.Instance.localPlayerController;
				Vector3 position = ((Component)localPlayerController).transform.position;
				if (localPlayerController.isPlayerDead && (Object)(object)localPlayerController.spectatedPlayerScript != (Object)null)
				{
					position = ((Component)localPlayerController.spectatedPlayerScript).transform.position;
				}
				Vector3 val = position - ((Component)Npc).transform.position;
				if (((Vector3)(ref val)).sqrMagnitude < 400f)
				{
					Npc.PlayFootstepSound();
				}
			}
		}

		public void PlayAudibleNoiseLethalBot(Vector3 noisePosition, float noiseRange = 10f, float noiseLoudness = 0.5f, int timesPlayedInSameSpot = 0, bool noiseIsInsideClosedShip = false, int noiseID = 0)
		{
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			if (noiseIsInsideClosedShip)
			{
				noiseRange /= 2f;
			}
			foreach (KeyValuePair<EnemyAI, INoiseListener> dictEnemyAINoiseListener in LethalBotManager.Instance.DictEnemyAINoiseListeners)
			{
				EnemyAI key = dictEnemyAINoiseListener.Key;
				if (!((Object)(object)key == (Object)null))
				{
					Vector3 val = ((Component)Npc).transform.position - ((Component)key).transform.position;
					if (!(((Vector3)(ref val)).sqrMagnitude > noiseRange * noiseRange) && (!noiseIsInsideClosedShip || key.isInsidePlayerShip || !(noiseLoudness < 0.9f)))
					{
						Plugin.LogDebug(Npc.playerUsername + " Play audible noise for " + ((Object)key).name);
						dictEnemyAINoiseListener.Value.DetectNoise(noisePosition, noiseLoudness, timesPlayedInSameSpot, noiseID);
					}
				}
			}
		}

		public void LateUpdate()
		{
			//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_0133: Unknown result type (might be due to invalid IL or missing references)
			//IL_04fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_050f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0519: Unknown result type (might be due to invalid IL or missing references)
			//IL_051e: Unknown result type (might be due to invalid IL or missing references)
			//IL_053e: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_020b: Unknown result type (might be due to invalid IL or missing references)
			//IL_021b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0220: Unknown result type (might be due to invalid IL or missing references)
			//IL_0225: Unknown result type (might be due to invalid IL or missing references)
			//IL_0266: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_02be: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0314: Unknown result type (might be due to invalid IL or missing references)
			GameNetworkManager instance = GameNetworkManager.Instance;
			Npc.previousElevatorPosition = Npc.playersManager.elevatorTransform.position;
			if ((Object)(object)NetworkManager.Singleton == (Object)null)
			{
				return;
			}
			if (Plugin.Config.EnableDebugLog.Value)
			{
				((TMP_Text)Npc.usernameBillboardText).text = LethalBotAIController.GetSizedBillboardStateIndicator();
			}
			else
			{
				((TMP_Text)Npc.usernameBillboardText).text = string.Empty;
			}
			if ((Object)(object)instance.localPlayerController != (Object)null && Npc.usernameAlpha.alpha >= 0f)
			{
				TextMeshProUGUI usernameBillboardText = Npc.usernameBillboardText;
				((TMP_Text)usernameBillboardText).text = ((TMP_Text)usernameBillboardText).text + "\n" + Npc.playerUsername;
				if (LethalBotAIController.IsClientOwnerOfLethalBot())
				{
					TextMeshProUGUI usernameBillboardText2 = Npc.usernameBillboardText;
					((TMP_Text)usernameBillboardText2).text = ((TMP_Text)usernameBillboardText2).text + "\nv";
				}
				CanvasGroup usernameAlpha = Npc.usernameAlpha;
				usernameAlpha.alpha -= Time.deltaTime;
				UpdateBillBoardLookAtTimedCheck.UpdateBillboardLookAt(Npc, SqrDistanceWithLocalPlayerTimedCheck.GetSqrDistanceWithLocalPlayer(((Component)Npc).transform.position) < 100f);
			}
			else if (((Component)Npc.usernameCanvas).gameObject.activeSelf)
			{
				((Component)Npc.usernameCanvas).gameObject.SetActive(false);
			}
			LethalBotAIController.HealthRegen();
			if (LethalBotAIController.IsClientOwnerOfLethalBot())
			{
				LethalBotRotationAndLookUpdate();
				if (Npc.isPlayerControlled && !Npc.isPlayerDead)
				{
					if ((Object)(object)instance != (Object)null)
					{
						float num = (Npc.inSpecialInteractAnimation ? 0.06f : ((!IsRealPlayerClose(((Component)Npc).transform.position, 10f)) ? 0.24f : 0.1f));
						Vector3 val = Npc.oldPlayerPosition - ((Component)Npc).transform.localPosition;
						if (((Vector3)(ref val)).sqrMagnitude > num || UpdatePositionForNewlyJoinedClient)
						{
							UpdatePositionForNewlyJoinedClient = false;
							if (!Npc.playersManager.newGameIsLoading)
							{
								LethalBotAIController.SyncUpdateLethalBotPosition(Npc.thisPlayerBody.localPosition, Npc.isInElevator, Npc.isInHangarShipRoom, Npc.isExhausted, IsTouchingGround);
								Npc.serverPlayerPosition = ((Component)Npc).transform.localPosition;
								Npc.oldPlayerPosition = Npc.serverPlayerPosition;
							}
						}
						GrabbableObject heldItem = LethalBotAIController.HeldItem;
						if ((Object)(object)heldItem != (Object)null && Npc.isHoldingObject && GrabbedObjectValidated)
						{
							((Component)heldItem).transform.localPosition = heldItem.itemProperties.positionOffset;
							((Component)heldItem).transform.localEulerAngles = heldItem.itemProperties.rotationOffset;
						}
					}
					float num2 = 1f;
					if (Npc.drunkness > 0.02f)
					{
						num2 *= Mathf.Abs(StartOfRound.Instance.drunknessSpeedEffect.Evaluate(Npc.drunkness) - 1.25f);
					}
					if (Npc.isSprinting)
					{
						Npc.sprintMeter = Mathf.Clamp(Npc.sprintMeter - Time.deltaTime / Npc.sprintTime * Npc.carryWeight * num2, 0f, 1f);
					}
					else if (Npc.isMovementHindered > 0)
					{
						if (IsWalking)
						{
							Npc.sprintMeter = Mathf.Clamp(Npc.sprintMeter - Time.deltaTime / Npc.sprintTime * num2 * 0.5f, 0f, 1f);
						}
					}
					else
					{
						if (!IsWalking)
						{
							Npc.sprintMeter = Mathf.Clamp(Npc.sprintMeter + Time.deltaTime / (Npc.sprintTime + 4f) * num2, 0f, 1f);
						}
						else
						{
							Npc.sprintMeter = Mathf.Clamp(Npc.sprintMeter + Time.deltaTime / (Npc.sprintTime + 9f) * num2, 0f, 1f);
						}
						if (Npc.isExhausted && Npc.sprintMeter > 0.2f)
						{
							Npc.isExhausted = false;
						}
					}
				}
			}
			if (!Npc.inSpecialInteractAnimation && Npc.localArmsMatchCamera)
			{
				Npc.localArmsTransform.position = ((Component)Npc.cameraContainerTransform).transform.position + ((Component)Npc.gameplayCamera).transform.up * -0.5f;
				Npc.playerModelArmsMetarig.rotation = Npc.localArmsRotationTarget.rotation;
			}
		}

		public void ReParentNotSpawnedTransform(Transform newParent)
		{
			if ((Object)(object)((Component)Npc).transform.parent != (Object)(object)newParent)
			{
				NetworkObject[] componentsInChildren = ((Component)Npc).GetComponentsInChildren<NetworkObject>();
				foreach (NetworkObject val in componentsInChildren)
				{
					val.AutoObjectParentSync = false;
				}
				Plugin.LogDebug($"{Npc.playerUsername} ReParent parent before {((Component)Npc).transform.parent}");
				((Component)Npc).transform.parent = newParent;
				Plugin.LogDebug($"{Npc.playerUsername} ReParent parent after {((Component)Npc).transform.parent}");
				NetworkObject[] componentsInChildren2 = ((Component)Npc).GetComponentsInChildren<NetworkObject>();
				foreach (NetworkObject val2 in componentsInChildren2)
				{
					val2.AutoObjectParentSync = true;
				}
			}
		}

		public bool CheckConditionsForSinkingInQuicksandLethalBot()
		{
			if (!IsTouchingGround)
			{
				return false;
			}
			if (Npc.inSpecialInteractAnimation || Object.op_Implicit((Object)(object)Npc.inAnimationWithEnemy) || Npc.isClimbingLadder)
			{
				return false;
			}
			if ((Object)(object)Npc.physicsParent != (Object)null)
			{
				return false;
			}
			if (Npc.isInHangarShipRoom)
			{
				return false;
			}
			if (Npc.isInElevator)
			{
				return false;
			}
			if (Npc.currentFootstepSurfaceIndex != 1 && Npc.currentFootstepSurfaceIndex != 4 && Npc.currentFootstepSurfaceIndex != 8 && Npc.currentFootstepSurfaceIndex != 7 && (!Npc.isInsideFactory || Npc.currentFootstepSurfaceIndex != 5))
			{
				return false;
			}
			return true;
		}

		private bool IsRealPlayerClose(Vector3 thisPosition, float distance)
		{
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			StartOfRound instance = StartOfRound.Instance;
			PlayerControllerB[] allPlayerScripts = instance.allPlayerScripts;
			foreach (PlayerControllerB val in allPlayerScripts)
			{
				if (!LethalBotManager.Instance.IsPlayerLethalBot(val) && (!Plugin.IsModLethalInternsLoaded || !LethalBotManager.IsPlayerIntern(val)))
				{
					Vector3 val2 = ((Component)val).transform.position - thisPosition;
					if (((Vector3)(ref val2)).sqrMagnitude < distance * distance)
					{
						return true;
					}
				}
			}
			return false;
		}

		public void MimicEmotes(PlayerControllerB playerToMimic)
		{
			if (playerToMimic.performingEmote)
			{
				if (Plugin.IsModTooManyEmotesLoaded)
				{
					CheckAndPerformTooManyEmote(playerToMimic);
				}
				else
				{
					PerformDefaultEmote(playerToMimic.playerBodyAnimator.GetInteger("emoteNumber"));
				}
			}
			else
			{
				StopPreformingEmote();
			}
		}

		public void PerformRandomEmote(bool allowTooManyEmotes = true)
		{
			if (Npc.performingEmote || !PlayerControllerBPatch.CheckConditionsForEmote_ReversePatch(Npc))
			{
				return;
			}
			if (allowTooManyEmotes && Plugin.IsModTooManyEmotesLoaded && Random.Range(1, 100) <= 50)
			{
				PlayerControllerB val = null;
				PlayerControllerB val2 = null;
				StartOfRound instance = StartOfRound.Instance;
				PlayerControllerB[] allPlayerScripts = instance.allPlayerScripts;
				foreach (PlayerControllerB val3 in allPlayerScripts)
				{
					if ((Object)(object)val != (Object)null && (Object)(object)val2 != (Object)null)
					{
						break;
					}
					if ((Object)(object)val == (Object)null && ((NetworkBehaviour)Npc).OwnerClientId == val3.actualClientId)
					{
						val = val3;
					}
					if ((Object)(object)val2 == (Object)null && IsTargetPerformingTooManyEmote(val3))
					{
						val2 = val3;
					}
				}
				if ((Object)(object)val2 != (Object)null && (Npc.isInElevator || Npc.isInHangarShipRoom))
				{
					CheckAndPerformTooManyEmote(val2);
					return;
				}
				if ((Object)(object)val == (Object)null)
				{
					val = Npc;
				}
				PreformRandomTooManyEmote(val);
			}
			else
			{
				PerformDefaultEmote(Random.Range(1, 3));
			}
		}

		private void PreformRandomTooManyEmote(PlayerControllerB ourOwner)
		{
			List<UnlockableEmote> value = SessionManager.unlockedEmotes;
			if (!ConfigSync.instance.syncShareEverything && (Object)(object)ourOwner != (Object)(object)StartOfRound.Instance.localPlayerController)
			{
				SessionManager.unlockedEmotesByPlayer.TryGetValue(ourOwner.playerUsername, out value);
			}
			if (value == null)
			{
				value = SessionManager.unlockedEmotes;
			}
			int index = Random.Range(0, value.Count);
			LethalBotAIController.PerformTooManyEmoteLethalBotAndSync(value[index].emoteId);
		}

		public void StopPreformingEmote(bool forceStop = false)
		{
			if (Npc.performingEmote || forceStop)
			{
				Npc.performingEmote = false;
				Npc.playerBodyAnimator.SetInteger("emoteNumber", 0);
				LethalBotAIController.SyncStopPerformingEmote();
				if (Plugin.IsModTooManyEmotesLoaded)
				{
					LethalBotAIController.StopPerformTooManyEmoteLethalBotAndSync();
				}
			}
		}

		private bool IsTargetPerformingTooManyEmote(PlayerControllerB playerToCheck)
		{
			EmoteControllerPlayer component = ((Component)playerToCheck).gameObject.GetComponent<EmoteControllerPlayer>();
			if ((Object)(object)component == (Object)null)
			{
				return false;
			}
			if (!((EmoteController)component).isPerformingEmote)
			{
				return false;
			}
			if (((EmoteController)component).performingEmote == null)
			{
				return false;
			}
			return true;
		}

		private void CheckAndPerformTooManyEmote(PlayerControllerB playerToMimic)
		{
			EmoteControllerPlayer component = ((Component)playerToMimic).gameObject.GetComponent<EmoteControllerPlayer>();
			if ((Object)(object)component == (Object)null)
			{
				return;
			}
			EmoteControllerPlayer component2 = ((Component)Npc).gameObject.GetComponent<EmoteControllerPlayer>();
			if ((Object)(object)component2 == (Object)null)
			{
				return;
			}
			if (!((EmoteController)component).isPerformingEmote)
			{
				if (((EmoteController)component2).isPerformingEmote)
				{
					((EmoteController)component2).StopPerformingEmote();
					LethalBotAIController.StopPerformTooManyEmoteLethalBotAndSync();
				}
				PerformDefaultEmote(playerToMimic.playerBodyAnimator.GetInteger("emoteNumber"));
			}
			else
			{
				if (((EmoteController)component).performingEmote == null || (((EmoteController)component2).isPerformingEmote && ((EmoteController)component).performingEmote.emoteId == ((EmoteController)component2).performingEmote?.emoteId))
				{
					return;
				}
				UnlockableEmote val = EmotesManager.allUnlockableEmotes[((EmoteController)component).performingEmote.emoteId];
				if (val != null && ((EmoteController)component2).isPerformingEmote && ((EmoteController)component2).performingEmote != null)
				{
					UnlockableEmote val2 = EmotesManager.allUnlockableEmotes[((EmoteController)component2).performingEmote.emoteId];
					if (val2.IsEmoteInEmoteGroup(val))
					{
						return;
					}
				}
				LethalBotAIController.PerformTooManyEmoteLethalBotAndSync(((EmoteController)component).performingEmote.emoteId, (int)playerToMimic.playerClientId);
			}
		}

		private void PerformDefaultEmote(int emoteNumberToMimic)
		{
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			int integer = Npc.playerBodyAnimator.GetInteger("emoteNumber");
			if ((!Npc.performingEmote || integer != emoteNumberToMimic) && PlayerControllerBPatch.CheckConditionsForEmote_ReversePatch(Npc))
			{
				Npc.performingEmote = true;
				Npc.PerformEmote(default(CallbackContext), emoteNumberToMimic);
			}
		}

		public void PerformTooManyEmote(int tooManyEmoteID, int playerToSync = -1)
		{
			EmoteControllerPlayer component = ((Component)Npc).gameObject.GetComponent<EmoteControllerPlayer>();
			if ((Object)(object)component == (Object)null)
			{
				return;
			}
			if (((EmoteController)component).isPerformingEmote)
			{
				((EmoteController)component).StopPerformingEmote();
			}
			PlayerControllerB val = null;
			if (playerToSync != -1)
			{
				PlayerControllerB[] allPlayerScripts = StartOfRound.Instance.allPlayerScripts;
				foreach (PlayerControllerB val2 in allPlayerScripts)
				{
					if ((Object)(object)val2 != (Object)null && (int)val2.playerClientId == playerToSync && val2.isPlayerControlled && !val2.isPlayerDead)
					{
						val = val2;
						break;
					}
				}
			}
			if ((Object)(object)val != (Object)null)
			{
				EmoteControllerPlayer component2 = ((Component)val).GetComponent<EmoteControllerPlayer>();
				int num = -1;
				((EmoteController)component).SyncWithEmoteController((EmoteController)(object)component2, num);
				if (((EmoteController)component).performingEmote != null)
				{
					if (((EmoteController)component).performingEmote.inEmoteSyncGroup)
					{
						num = ((EmoteController)component).performingEmote.emoteSyncGroup.IndexOf(((EmoteController)component).performingEmote);
					}
					Npc.StartPerformingEmoteServerRpc();
					SyncPerformingEmoteManager.SendSyncEmoteUpdateToServer((EmoteController)(object)component, num);
					component.timeSinceStartingEmote = 0f;
					Npc.performingEmote = true;
					Plugin.LogDebug("Lethal Bot " + Npc.playerUsername + " successfuly synced emote with " + val.playerUsername + "!");
					return;
				}
			}
			UnlockableEmote val3 = EmotesManager.allUnlockableEmotes[tooManyEmoteID];
			((EmoteController)component).PerformEmote(val3, -1, false);
		}

		public void StopPerformingTooManyEmote()
		{
			EmoteControllerPlayer component = ((Component)Npc).gameObject.GetComponent<EmoteControllerPlayer>();
			if ((Object)(object)component != (Object)null)
			{
				((EmoteController)component).StopPerformingEmote();
			}
		}

		private void LethalBotRotationAndLookUpdate()
		{
			if (Npc.isPlayerControlled && Npc.playersManager.connectedPlayersAmount >= 1 && !Npc.playersManager.newGameIsLoading && !Npc.disableLookInput && !(oldLookAtTarget == LookAtTarget) && UpdatePlayerLookInterval > 0.25f)
			{
				UpdatePlayerLookInterval = 0f;
				LethalBotAIController.SyncUpdateLethalBotRotationAndLook(LethalBotAIController.State?.GetBillboardStateIndicator() ?? "", LookAtTarget);
				oldLookAtTarget = LookAtTarget.Clone();
			}
		}

		public void OrderToMove()
		{
			HasToMove = true;
		}

		public void OrderToStopMoving()
		{
			HasToMove = false;
			floatSprint = 0f;
		}

		public void OrderToSprint()
		{
			if (Npc.inSpecialInteractAnimation || !IsTouchingGround || Npc.isClimbingLadder || IsJumping)
			{
				return;
			}
			if (Npc.isExhausted)
			{
				floatSprint = 0f;
			}
			else
			{
				if (Npc.isSprinting)
				{
					return;
				}
				if ((Object)(object)LethalBotAIController != (Object)null && LethalBotAIController.State != null)
				{
					bool? flag = LethalBotAIController.State.ShouldBotCrouch();
					if (flag.HasValue && flag.Value)
					{
						floatSprint = 0f;
						return;
					}
				}
				floatSprint = 1f;
			}
		}

		public void OrderToStopSprint()
		{
			if (Npc.isSprinting)
			{
				floatSprint = 0f;
			}
		}

		public void OrderToToggleCrouch()
		{
			if (!Npc.inSpecialInteractAnimation && IsTouchingGround && !Npc.isClimbingLadder && !IsJumping && (!Npc.isSprinting || Npc.isCrouching))
			{
				CrouchMeter = Mathf.Min(CrouchMeter + 0.3f, 1.3f);
				Npc.Crouch(!Npc.isCrouching);
			}
		}

		public void SetTurnBodyTowardsDirectionWithPosition(Vector3 positionDirection)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			LookAtTarget.directionToUpdateTurnBodyTowardsTo = positionDirection - ((Component)Npc.thisController).transform.position;
		}

		public void SetTurnBodyTowardsDirection(Vector3 direction)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			LookAtTarget.directionToUpdateTurnBodyTowardsTo = direction;
		}

		private void UpdateTurnBodyTowardsDirection()
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			if (!IsControllerInCruiser)
			{
				UpdateNowTurnBodyTowardsDirection(LookAtTarget.directionToUpdateTurnBodyTowardsTo);
			}
		}

		public void UpdateNowTurnBodyTowardsDirection(Vector3 direction)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: 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_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: 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)
			if (DirectionNotZero(direction.x) || DirectionNotZero(direction.z))
			{
				Quaternion val = Quaternion.LookRotation(new Vector3(direction.x, 0f, direction.z));
				Npc.thisPlayerBody.rotation = Quaternion.Lerp(Npc.thisPlayerBody.rotation, val, 6f * Time.deltaTime);
			}
		}

		public void OrderToLookAtPlayer(PlayerControllerB playerToLookAt)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			LookAtTarget.enumObjectsLookingAt = EnumObjectsLookingAt.Position;
			LookAtTarget.AimHeadTowards(NetworkObjectReference.op_Implicit(((NetworkBehaviour)playerToLookAt).NetworkObject), EnumLookAtPriority.MEDIUM_PRIORITY, 0f, bypassSteadyCheck: true);
		}

		public void OrderToLookForward()
		{
			LookAtTarget.enumObjectsLookingAt = EnumObjectsLookingAt.Forward;
			LookAtTarget.lookAtPriority = EnumLookAtPriority.LOW_PRIORITY;
		}

		public void OrderToLookAtPosition(Vector3 lookAtPos, EnumLookAtPriority priority = EnumLookAtPriority.LOW_PRIORITY, float duration = 0f, bool bypassSteadyCheck = false, float maxBodyFOV = 90f)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			LookAtTarget.enumObjectsLookingAt = EnumObjectsLookingAt.Position;
			LookAtTarget.AimHeadTowards(lookAtPos, priority, duration, bypassSteadyCheck, maxBodyFOV);
		}

		public void OrderToLookAtPosition(NetworkObject lookAtSubject, EnumLookAtPriority priority = EnumLookAtPriority.LOW_PRIORITY, float duration = 0f, bool bypassSteadyCheck = false, float maxBodyFOV = 90f)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			LookAtTarget.enumObjectsLookingAt = EnumObjectsLookingAt.Position;
			LookAtTarget.AimHeadTowards(NetworkObjectReference.op_Implicit(lookAtSubject), priority, duration, bypassSteadyCheck, maxBodyFOV);
		}

		public void SetCurrentLookAt(LookAtTarget lookAtTarget)
		{
			oldLookAtTarget = LookAtTarget.Clone();
			LookAtTarget = lookAtTarget;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private void UpdateLookAt()
		{
			LookAtTarget.Update(this, LethalBotAIController);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public bool IsMoving()
		{
			//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_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			if (!(MoveVector != Vector3.zero) && animationHashLayers[0] == -1437577361)
			{
				AnimatorStateInfo currentAnimatorStateInfo = Npc.playerBodyAnimator.GetCurrentAnimatorStateInfo(0);
				return ((AnimatorStateInfo)(ref currentAnimatorStateInfo)).fullPathHash != -1437577361;
			}
			return true;
		}

		private void ForceTurnTowardsTarget()
		{
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_0360: Unknown result type (might be due to invalid IL or missing references)
			//IL_0365: Unknown result type (might be due to invalid IL or missing references)
			//IL_034d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0352: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0367: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Unknown result type (might be due to invalid IL or missing references)
			//IL_0139: Unknown result type (might be due to invalid IL or missing references)
			//IL_0196: Unknown result type (might be due to invalid IL or missing references)
			//IL_019b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_01af: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_028f: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0309: Unknown result type (might be due to invalid IL or missing references)
			PlayerControllerB npc = Npc;
			if (npc.inSpecialInteractAnimation && npc.inShockingMinigame && (Object)(object)npc.shockingTarget != (Object)null)
			{
				OrderToLookAtPosition(Npc.shockingTarget.position, EnumLookAtPriority.MAXIMUM_PRIORITY, 0f, bypassSteadyCheck: false, 60f);
				npc.targetScreenPos = npc.turnCompassCamera.WorldToViewportPoint(npc.shockingTarget.position);
				npc.shockMinigamePullPosition = npc.targetScreenPos.x - 0.5f;
				float num = Mathf.Clamp(Time.deltaTime, 0f, 0.1f);
				if (npc.targetScreenPos.x > 0.54f)
				{
					npc.turnCompass.Rotate(Vector3.up * 2000f * num * Mathf.Abs(npc.shockMinigamePullPosition));
					npc.playerBodyAnimator.SetBool("PullingCameraRight", false);
					npc.playerBodyAnimator.SetBool("PullingCameraLeft", true);
				}
				else if (npc.targetScreenPos.x < 0.46f)
				{
					npc.turnCompass.Rotate(Vector3.up * -2000f * num * Mathf.Abs(npc.shockMinigamePullPosition));
					npc.playerBodyAnimator.SetBool("PullingCameraLeft", false);
					npc.playerBodyAnimator.SetBool("PullingCameraRight", true);
				}
				else
				{
					npc.playerBodyAnimator.SetBool("PullingCameraLeft", false);
					npc.playerBodyAnimator.SetBool("PullingCameraRight", false);
				}
				npc.targetScreenPos = npc.gameplayCamera.WorldToViewportPoint(npc.shockingTarget.position + Vector3.up * 0.35f);
				if (npc.targetScreenPos.y > 0.6f)
				{
					CameraUp = Mathf.Clamp(Mathf.Lerp(CameraUp, CameraUp - 25f, 25f * num * Mathf.Abs(npc.targetScreenPos.y - 0.5f)), -89f, 89f);
				}
				else if (npc.targetScreenPos.y < 0.35f)
				{
					CameraUp = Mathf.Clamp(Mathf.Lerp(CameraUp, CameraUp + 25f, 25f * num * Mathf.Abs(npc.targetScreenPos.y - 0.5f)), -89f, 89f);
				}
				((Component)npc.gameplayCamera).transform.localEulerAngles = new Vector3(CameraUp, ((Component)npc.gameplayCamera).transform.localEulerAngles.y, ((Component)npc.gameplayCamera).transform.localEulerAngles.z);
				Vector3 zero = Vector3.zero;
				zero.y = npc.turnCompass.eulerAngles.y;
				npc.thisPlayerBody.rotation = Quaternion.Lerp(npc.thisPlayerBody.rotation, Quaternion.Euler(zero), Time.deltaTime * 20f * (1f - Mathf.Abs(npc.shockMinigamePullPosition)));
			}
			else if (Object.op_Implicit((Object)(object)npc.inAnimationWithEnemy) && (Object)(object)EnemyInAnimationWith != (Object)null)
			{
				Vector3 lookAtPos = ((!((Object)(object)EnemyInAnimationWith.eye != (Object)null)) ? ((Component)EnemyInAnimationWith).transform.position : EnemyInAnimationWith.eye.position);
				OrderToLookAtPosition(lookAtPos, EnumLookAtPriority.MAXIMUM_PRIORITY);
			}
		}

		public void OrderToGoUpDownLadder(bool hasToGoDown)
		{
			goDownLadder = hasToGoDown;
		}

		public bool CanUseLadder(InteractTrigger ladder)
		{
			if (LethalBotAIController.useLadderCoroutine != null)
			{
				return false;
			}
			if (Npc.sinkingValue > 0.73f)
			{
				return false;
			}
			if (Npc.jetpackControls && (ladder.specialCharacterAnimation || ladder.isLadder))
			{
				return false;
			}
			if (Npc.isClimbingLadder)
			{
				if (!ladder.isLadder && ladder.specialCharacterAnimation)
				{
					return false;
				}
			}
			else if (Npc.inSpecialInteractAnimation)
			{
				return false;
			}
			if (ladder.isPlayingSpecialAnimation)
			{
				return false;
			}
			return true;
		}

		public void SetAnimationBoolForItem(string animationString, bool value)
		{
			if (dictAnimationBoolPerItem == null)
			{
				dictAnimationBoolPerItem = new Dictionary<string, bool>();
			}
			dictAnimationBoolPerItem[animationString] = value;
		}

		internal bool DirectionNotZero(float direction)
		{
			if (!(direction < -0.01f))
			{
				return 0.01f < direction;
			}
			return true;
		}

		private void SetFaceUnderwaterFilters()
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			if (Npc.isPlayerDead)
			{
				return;
			}
			if ((Object)(object)Npc.underwaterCollider != (Object)null)
			{
				Bounds bounds = Npc.underwaterCollider.bounds;
				if (((Bounds)(ref bounds)).Contains(((Component)Npc.gameplayCamera).transform.position))
				{
					setFaceUnderwater = true;
					Npc.statusEffectAudio.volume = Mathf.Lerp(Npc.statusEffectAudio.volume, 0f, 4f * Time.deltaTime);
					DrowningTimer -= Time.deltaTime / 12f;
					if (DrowningTimer < 0f)
					{
						DrowningTimer = 1f;
						Plugin.LogDebug($"SyncKillLethalBot from drowning for LOCAL client #{((NetworkBehaviour)Npc).NetworkManager.LocalClientId}, bot object: Bot #{Npc.playerClientId}");
						Npc.KillPlayer(Vector3.zero, true, (CauseOfDeath)9, 0, default(Vector3), false);
					}
					goto IL_0176;
				}
			}
			setFaceUnderwater = false;
			Npc.statusEffectAudio.volume = Mathf.Lerp(Npc.statusEffectAudio.volume, 1f, 4f * Time.deltaTime);
			DrowningTimer = Mathf.Clamp(DrowningTimer + Time.deltaTime, 0.1f, 1f);
			goto IL_0176;
			IL_0176:
			syncUnderwaterInterval -= Time.deltaTime;
			if (syncUnderwaterInterval <= 0f)
			{
				syncUnderwaterInterval = 0.5f;
				if (setFaceUnderwater && !Npc.isUnderwater)
				{
					Npc.isUnderwater = true;
					LethalBotAIController.SyncSetFaceUnderwaterServerRpc(Npc.isUnderwater);
				}
				else if (!setFaceUnderwater && Npc.isUnderwater)
				{
					Npc.isUnderwater = false;
					LethalBotAIController.SyncSetFaceUnderwaterServerRpc(Npc.isUnderwater);
				}
			}
		}

		public void RefreshBillBoardPosition()
		{
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			if (Plugin.IsModModelReplacementAPILoaded)
			{
				((Component)Npc.usernameCanvas).transform.localPosition = GetBillBoardPositionModelReplacementAPI(((Component)Npc.usernameCanvas).transform.localPosition);
			}
			else
			{
				((Component)Npc.usernameCanvas).transform.localPosition = GetBillBoardPosition(((Component)Npc).gameObject, ((Component)Npc.usernameCanvas).transform.localPosition);
			}
		}

		private Vector3 GetBillBoardPositionModelReplacementAPI(Vector3 lastPosition)
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: 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)
			BodyReplacementBase component = ((Component)Npc).gameObject.GetComponent<BodyReplacementBase>();
			if ((Object)(object)component == (Object)null)
			{
				return GetBillBoardPosition(((Component)Npc).gameObject, lastPosition);
			}
			GameObject replacementModel = component.replacementModel;
			if ((Object)(object)replacementModel == (Object)null)
			{
				return GetBillBoardPosition(((Component)Npc).gameObject, lastPosition);
			}
			return GetBillBoardPosition(replacementModel, ((Component)Npc.usernameCanvas).transform.localPosition);
		}

		private Vector3 GetBillBoardPosition(GameObject bodyModel, Vector3 lastPosition)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			Bounds boundsModel = GetBoundsTimedCheck.GetBoundsModel(bodyModel);
			return new Vector3(lastPosition.x, ((Bounds)(ref boundsModel)).center.y - ((Component)Npc).transform.position.y + ((Bounds)(ref boundsModel)).extents.y, lastPosition.z);
		}
	}
}
namespace LethalBots.AI.AIStates
{
	public class BrainDeadState : AIState
	{
		private bool hasVotedToLeave;

		private CountdownTimer voteIntervalTimer = new CountdownTimer();

		public BrainDeadState(LethalBotAI ai)
			: base(ai)
		{
			hasVotedToLeave = false;
			base.CurrentState = EnumAIStates.BrainDead;
		}

		public override void DoAI()
		{
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			base.ai.StopMoving();
			StartOfRound instance = StartOfRound.Instance;
			if (hasVotedToLeave || LethalBotManager.IsTheShipLeaving(instance) || TimeOfDay.Instance.shipLeavingAlertCalled || (voteIntervalTimer.HasStarted() && !voteIntervalTimer.Elapsed()))
			{
				return;
			}
			voteIntervalTimer.Start(Random.Range(0.5f, 1.5f));
			if (npcController.Npc.isPlayerControlled || !npcController.Npc.isPlayerDead)
			{
				if (((NetworkBehaviour)base.ai).IsOwner)
				{
					base.ai.State = base.ai.GetDesiredAIState();
				}
			}
			else if (!LethalBotManager.AreWeInOrbit(instance))
			{
				if (LethalBotManager.Instance.LootTransferPlayers.Contains(NetworkBehaviourReference.op_Implicit((NetworkBehaviour)(object)npcController.Npc)))
				{
					LethalBotManager.Instance.RemovePlayerFromLootTransferListAndSync(NetworkBehaviourReference.op_Implicit((NetworkBehaviour)(object)npcController.Npc));
				}
				if (GroupManager.Instance.IsPlayerInGroup(npcController.Npc))
				{
					GroupManager.Instance.RemoveFromCurrentGroupAndSync(npcController.Npc);
				}
				bool flag = LethalBotManager.Instance.AreAllPlayersOnTheShip();
				bool flag2 = LethalBotManager.Instance.AreAllHumanPlayersDead();
				bool flag3 = LethalBotManager.IsShipCompromised(base.ai);
				if (flag && (flag2 || flag3) && (ShouldReturnToShip() || (instance.livingPlayers <= 1 && flag3)))
				{
					Plugin.LogDebug("Bot " + npcController.Npc.playerUsername + " is attempting to vote to leave early!");
					TimeOfDay.Instance.SetShipLeaveEarlyServerRpc();
					hasVotedToLeave = true;
				}
			}
		}

		public override void TryPlayCurrentStateVoiceAudio()
		{
			if (Plugin.Config.AllowTalkingWhileDead.Value)
			{
				base.ai.LethalBotIdentity.Voice.TryPlayVoiceAudio(new PlayVoiceParameters
				{
					VoiceState = EnumVoicesState.Chilling,
					CanTalkIfOtherLethalBotTalk = false,
					WaitForCooldown = true,
					CutCurrentVoiceStateToTalk = false,
					CanRepeatVoiceState = true,
					ShouldSync = true,
					IsLethalBotInside = npcController.Npc.isInsideFactory,
					AllowSwearing = Plugin.Config.AllowSwearing.Value
				});
			}
			else
			{
				base.ai.LethalBotIdentity.Voice.TryStopAudioFadeOut();
			}
		}

		public new static void RegisterChatCommands()
		{
			ChatCommandsManager.RegisterIgnoreDefaultForState<BrainDeadState>();
		}

		public new static void RegisterSignalTranslatorCommands()
		{
			SignalTranslatorCommandsManager.RegisterIgnoreDefaultForState<BrainDeadState>();
		}
	}
	public class ChargeHeldItemState : AIState
	{
		private GrabbableObject? itemToCharge;

		private bool chargeAllHeldItems;

		public ChargeHeldItemState(AIState oldState, GrabbableObject? itemToCharge, AIState? changeToOnEnd = null)
			: base(oldState, changeToOnEnd)
		{
			base.CurrentState = EnumAIStates.ChargeHeldItem;
			if ((Object)(object)itemToCharge != (Object)null)
			{
				this.itemToCharge = itemToCharge;
			}
			else
			{
				this.itemToCharge = base.ai.HeldItem;
			}
		}

		public ChargeHeldItemState(AIState oldState, bool chargeAllHeldItems = false, AIState? changeToOnEnd = null)
			: base(oldState, changeToOnEnd)
		{
			base.CurrentState = EnumAIStates.ChargeHeldItem;
			this.chargeAllHeldItems = chargeAllHeldItems;
			itemToCharge = base.ai.HeldItem;
		}

		public ChargeHeldItemState(LethalBotAI ai, GrabbableObject? itemToCharge, AIState? changeToOnEnd = null)
			: base(ai)
		{
			base.CurrentState = EnumAIStates.ChargeHeldItem;
			previousAIState = changeToOnEnd ?? new ReturnToShipState(this);
			if ((Object)(object)itemToCharge != (Object)null)
			{
				this.itemToCharge = itemToCharge;
			}
			else
			{
				this.itemToCharge = ai.HeldItem;
			}
		}

		public override void DoAI()
		{
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_017b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0190: Unknown result type (might be due to invalid IL or missing references)
			//IL_0195: Unknown result type (might be due to invalid IL or missing references)
			//IL_019a: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ba: Unknown result type (might be due to invalid IL or missing references)
			EnemyAI val = base.ai.CheckLOSForEnemy(90f, 40, 5);
			if ((Object)(object)val != (Object)null)
			{
				base.ai.State = new PanikState(this, val);
				return;
			}
			if (!npcController.Npc.isInElevator && !npcController.Npc.isInHangarShipRoom)
			{
				ChangeBackToPreviousState();
				return;
			}
			if (npcController.Npc.inTerminalMenu)
			{
				base.ai.LeaveTerminal();
				return;
			}
			GrabbableObject heldItem = base.ai.HeldItem;
			Vector3 placePosition;
			if ((Object)(object)heldItem != (Object)(object)itemToCharge)
			{
				if (base.ai.HasGrabbableObjectInInventory(itemToCharge, out var objectSlot))
				{
					if ((Object)(object)heldItem != (Object)null && heldItem.itemProperties.twoHanded)
					{
						LethalBotAI lethalBotAI = base.ai;
						placePosition = default(Vector3);
						lethalBotAI.DropItem(placeObject: false, null, placePosition);
						LethalBotAI.DictJustDroppedItems.Remove(heldItem);
					}
					else
					{
						base.ai.SwitchItemSlotsAndSync(objectSlot);
					}
					return;
				}
				itemToCharge = null;
			}
			if ((Object)(object)itemToCharge != (Object)null && itemToCharge.itemProperties.requiresBattery && (itemToCharge.insertedBattery.empty || itemToCharge.insertedBattery.charge < 0.9f))
			{
				ItemCharger val2 = Object.FindObjectOfType<ItemCharger>();
				if (!((Object)(object)val2 != (Object)null))
				{
					return;
				}
				InteractTrigger triggerScript = val2.triggerScript;
				if (!((Object)(object)triggerScript != (Object)null))
				{
					return;
				}
				placePosition = triggerScript.playerPositionNode.position - ((Component)npcController.Npc).transform.position;
				float sqrMagnitude = ((Vector3)(ref placePosition)).sqrMagnitude;
				if (sqrMagnitude > 1f)
				{
					base.ai.SetDestinationToPositionLethalBotAI(triggerScript.playerPositionNode.position);
					if (!npcController.WaitForFullStamina && sqrMagnitude > 64f)
					{
						npcController.OrderToSprint();
					}
					else if (npcController.WaitForFullStamina || sqrMagnitude < 49f)
					{
						npcController.OrderToStopSprint();
					}
					base.ai.OrderMoveToDestination();
				}
				else
				{
					base.ai.StopMoving();
					if (!base.ai.TurnOffHeldItem())
					{
						base.ai.UseItemCharger(val2);
					}
				}
			}
			else if (!chargeAllHeldItems || !HasItemToCharge(base.ai, out itemToCharge))
			{
				ChangeBackToPreviousState();
			}
		}

		public override void TryPlayCurrentStateVoiceAudio()
		{
		}

		public static bool HasItemToCharge(LethalBotAI lethalBotAI, out GrabbableObject? itemToCharge)
		{
			GrabbableObject itemOnlySlot = lethalBotAI.NpcController.Npc.ItemOnlySlot;
			if ((Object)(object)itemOnlySlot != (Object)null && itemOnlySlot.itemProperties.requiresBattery && (itemOnlySlot.insertedBattery.empty || itemOnlySlot.insertedBattery.charge < 0.9f))
			{
				itemToCharge = itemOnlySlot;
				return true;
			}
			GrabbableObject[] itemSlots = lethalBotAI.NpcController.Npc.ItemSlots;
			foreach (GrabbableObject val in itemSlots)
			{
				if ((Object)(object)val != (Object)null && val.itemProperties.requiresBattery && (val.insertedBattery.empty || val.insertedBattery.charge < 0.9f))
				{
					itemToCharge = val;
					return true;
				}
			}
			itemToCharge = null;
			return false;
		}
	}
	public class ChillAtShipState : AIState
	{
		private float chillAtShipTimer;

		private float leavePlanetTimer;

		public ChillAtShipState(AIState oldState)
			: base(oldState)
		{
			base.CurrentState = EnumAIStates.ChillAtShip;
		}

		public ChillAtShipState(LethalBotAI ai)
			: base(ai)
		{
			base.CurrentState = EnumAIStates.ChillAtShip;
		}

		public override void OnEnterState()
		{
			PlayerControllerB npc = npcController.Npc;
			int groupId = GroupManager.Instance.GetGroupId(npc);
			if (groupId != -1 && (Object)(object)GroupManager.Instance.GetGroupLeader(groupId) != (Object)(object)npc)
			{
				GroupManager.Instance.RemoveFromCurrentGroupAndSync(npc);
			}
			base.OnEnterState();
		}

		public override void OnExitState(AIState newState)
		{
			base.OnExitState(newState);
			npcController.StopPreformingEmote();
		}

		public override void DoAI()
		{
			//IL_016a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			EnemyAI val = base.ai.CheckLOSForEnemy(90f, 40, 5);
			if ((Object)(object)val != (Object)null)
			{
				base.ai.State = new PanikState(this, val);
				return;
			}
			if (!npcController.Npc.isInElevator && !npcController.Npc.isInHangarShipRoom)
			{
				base.ai.State = new ReturnToShipState(this);
				return;
			}
			if (ChargeHeldItemState.HasItemToCharge(base.ai, out GrabbableObject _))
			{
				base.ai.State = new ChargeHeldItemState(this, chargeAllHeldItems: true, new ReturnToShipState(this));
				return;
			}
			bool flag = true;
			if (npcController.Npc.isInHangarShipRoom)
			{
				PlayerControllerB missionControlPlayer = LethalBotManager.Instance.MissionControlPlayer;
				if ((Object)(object)missionControlPlayer == (Object)(object)npcController.Npc)
				{
					base.ai.State = new MissionControlState(this);
					return;
				}
				int objectSlot;
				if (!base.ai.AreHandsFree() && FindObject(base.ai.HeldItem))
				{
					if (!base.ai.TurnOffHeldItem())
					{
						base.ai.DropItem();
					}
					flag = false;
				}
				else if (base.ai.HasGrabbableObjectInInventory((Func<GrabbableObject, bool>)FindObject, out objectSlot))
				{
					base.ai.SwitchItemSlotsAndSync(objectSlot);
					flag = false;
				}
				else
				{
					if (LethalBotManager.Instance.LootTransferPlayers.Contains(NetworkBehaviourReference.op_Implicit((NetworkBehaviour)(object)npcController.Npc)))
					{
						if (previousAIState is TransferLootState)
						{
							ChangeBackToPreviousState();
						}
						else
						{
							base.ai.State = new TransferLootState(this);
						}
						return;
					}
					if ((Plugin.Config.AllowBotsInOrbit.Value || !StartOfRound.Instance.shipIsLeaving) && ((Object)(object)missionControlPlayer == (Object)null || !missionControlPlayer.isPlayerControlled || missionControlPlayer.isPlayerDead) && (Plugin.Config.AllowBotsInOrbit.Value || !LethalBotManager.AreWeInOrbit()) && Plugin.Config.AutoMissionControl.Value)
					{
						LethalBotManager.Instance.MissionControlPlayer = npcController.Npc;
						flag = false;
					}
				}
			}
			if (flag)
			{
				PlayerControllerB val2 = base.ai.LookingForPlayerToRevive(ignoreLOS: true, shipOnly: true);
				if ((Object)(object)val2 != (Object)null)
				{
					base.ai.State = new RescueAndReviveState(this, val2);
					return;
				}
				if (CollectPurchasedItemsState.IsPossible())
				{
					base.ai.State = new CollectPurchasedItemsState(this);
					return;
				}
				val2 = base.ai.LookingForPlayerToHeal(ignoreLOS: true, shipOnly: true);
				if ((Object)(object)val2 != (Object)null)
				{
					base.ai.State = new HealPlayerState(this, val2);
					return;
				}
			}
			if (LethalBotManager.IsInverseTeleporterActive && flag)
			{
				base.ai.State = new UseInverseTeleporterState(this);
				return;
			}
			if (LethalBotManager.AreWeAtTheCompanyBuilding())
			{
				if (DoCompanyBuildingLogic())
				{
					return;
				}
			}
			else if (LethalBotManager.AreWeInOrbit())
			{
				if (DoOrbitLogic())
				{
					return;
				}
			}
			else if (DoStandardLogic())
			{
				return;
			}
			base.ai.StopMoving();
			npcController.PerformRandomEmote();
			chillAtShipTimer += ((EnemyAI)base.ai).AIIntervalTime;
		}

		public override bool? ShouldBotCrouch()
		{
			return base.ShouldBotCrouch() ?? new bool?(false);
		}

		public override void TryPlayCurrentStateVoiceAudio()
		{
			base.ai.LethalBotIdentity.Voice.TryPlayVoiceAudio(new PlayVoiceParameters
			{
				VoiceState = EnumVoicesState.Chilling,
				CanTalkIfOtherLethalBotTalk = false,
				WaitForCooldown = true,
				CutCurrentVoiceStateToTalk = false,
				CanRepeatVoiceState = true,
				ShouldSync = true,
				IsLethalBotInside = npcController.Npc.isInsideFactory,
				AllowSwearing = Plugin.Config.AllowSwearing.Value
			});
		}

		public new static void RegisterSignalTranslatorCommands()
		{
			SignalTranslatorCommandsManager.RegisterCommandForState<ChillAtShipState>(new SignalTranslatorCommand("return", (AIState state, LethalBotAI lethalBotAI, string message) => true));
		}

		private bool DoStandardLogic()
		{
			if (chillAtShipTimer > 20f)
			{
				PlayerControllerB val = base.ai.CheckLOSForClosestPlayer(90f, 40, 5);
				if ((Object)(object)val != (Object)null && !LethalBotManager.Instance.IsPlayerLethalBot(val) && (Object)(object)val != (Object)(object)LethalBotManager.Instance.MissionControlPlayer && !GroupManager.Instance.IsPlayerGroupLeader(npcController.Npc, out var _))
				{
					if (!base.ai.CheckProximityForEyelessDogs())
					{
						base.ai.LethalBotIdentity.Voice.TryPlayVoiceAudio(new PlayVoiceParameters
						{
							VoiceState = EnumVoicesState.LostAndFound,
							CanTalkIfOtherLethalBotTalk = true,
							WaitForCooldown = false,
							CutCurrentVoiceStateToTalk = true,
							CanRepeatVoiceState = false,
							ShouldSync = true,
							IsLethalBotInside = npcController.Npc.isInsideFactory,
							AllowSwearing = Plugin.Config.AllowSwearing.Value
						});
					}
					GroupManager.Instance.CreateOrJoinGroupWithMembersAndSync(val, (PlayerControllerB[])(object)new PlayerControllerB[1] { npcController.Npc });
					base.ai.SyncAssignTargetAndSetMovingTo(val);
					if (Plugin.Config.ChangeSuitAutoBehaviour.Value)
					{
						base.ai.ChangeSuitLethalBotServerRpc(npcController.Npc.playerClientId, val.currentSuitID);
					}
					return true;
				}
				if (!ShouldReturnToShip())
				{
					if (chillAtShipTimer > 22f)
					{
						if (LethalBotManager.IsThereATrappedPlayer && !base.ai.HasKeyInInventory())
						{
							GrabbableObject val2 = base.ai.FindItemOnShip((GrabbableObject foundItem) => foundItem is KeyItem) ?? base.ai.FindItemOnShip((GrabbableObject foundItem) => foundItem is LockPicker);
							if ((Object)(object)val2 != (Object)null)
							{
								base.ai.State = new FetchingObjectState(this, val2, EnumGrabbableObjectCall.Default, new SearchingForScrapState(this));
								return true;
							}
						}
						base.ai.State = new SearchingForScrapState(this);
						return true;
					}
				}
				else if (LethalBotManager.Instance.AreAllHumanPlayersDead() && LethalBotManager.Instance.AreAllPlayersOnTheShip())
				{
					if (leavePlanetTimer > 5f)
					{
						StartOfRound playersManager = npcController.Npc.playersManager;
						if ((LethalBotManager.IsTheShipLanded(playersManager) || LethalBotManager.AreWeInOrbit(playersManager)) && !LethalBotManager.IsTheShipLeaving(playersManager))
						{
							StartMatchLever val3 = Object.FindObjectOfType<StartMatchLever>();
							if ((Object)(object)val3 != (Object)null)
							{
								base.ai.PullShipLever(val3);
							}
						}
					}
					else
					{
						leavePlanetTimer += ((EnemyAI)base.ai).AIIntervalTime;
					}
				}
				else
				{
					leavePlanetTimer = 0f;
				}
			}
			return false;
		}

		private bool DoOrbitLogic()
		{
			return false;
		}

		private bool DoCompanyBuildingLogic()
		{
			if (chillAtShipTimer > 2f)
			{
				if ((Object)(object)base.ai.LookingForObjectsToSell(ignoreHeldFlag: true) != (Object)null || LethalBotManager.AreThereItemsOnDesk())
				{
					base.ai.State = new CollectScrapToSellState(this);
					return true;
				}
				if (LethalBotManager.Instance.AreAllHumanPlayersDead() && LethalBotManager.Instance.AreAllPlayersOnTheShip())
				{
					if (leavePlanetTimer > 5f)
					{
						StartOfRound playersManager = npcController.Npc.playersManager;
						if ((LethalBotManager.IsTheShipLanded(playersManager) || LethalBotManager.AreWeInOrbit(playersManager)) && !LethalBotManager.IsTheShipLeaving(playersManager))
						{
							StartMatchLever val = Object.FindObjectOfType<StartMatchLever>();
							if ((Object)(object)val != (Object)null)
							{
								base.ai.PullShipLever(val);
							}
						}
					}
					else
					{
						leavePlanetTimer += ((EnemyAI)base.ai).AIIntervalTime;
					}
				}
				else
				{
					leavePlanetTimer = 0f;
				}
			}
			return false;
		}
	}
	public class ChillWithPlayerState : AIState
	{
		private CountdownTimer entranceDropTimer = new CountdownTimer();

		private float SqrHorizontalDistanceWithTarget
		{
			get
			{
				//IL_0010: Unknown result type (might be due to invalid IL or missing references)
				//IL_0025: Unknown result type (might be due to invalid IL or missing references)
				//IL_002a: Unknown result type (might be due to invalid IL or missing references)
				//IL_003e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0043: Unknown result type (might be due to invalid IL or missing references)
				//IL_0048: Unknown result type (might be due to invalid IL or missing references)
				Vector3 val = Vector3.Scale(((Component)((EnemyAI)base.ai).targetPlayer).transform.position - ((Component)npcController.Npc).transform.position, new Vector3(1f, 0f, 1f));
				return ((Vector3)(ref val)).sqrMagnitude;
			}
		}

		private float SqrVerticalDistanceWithTarget
		{
			get
			{
				//IL_0010: Unknown result type (might be due to invalid IL or missing references)
				//IL_0025: Unknown result type (might be due to invalid IL or missing references)
				//IL_002a: Unknown result type (might be due to invalid IL or missing references)
				//IL_003e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0043: Unknown result type (might be due to invalid IL or missing references)
				//IL_0048: Unknown result type (might be due to invalid IL or missing references)
				Vector3 val = Vector3.Scale(((Component)((EnemyAI)base.ai).targetPlayer).transform.position - ((Component)npcController.Npc).transform.position, new Vector3(0f, 1f, 0f));
				return ((Vector3)(ref val)).sqrMagnitude;
			}
		}

		public ChillWithPlayerState(LethalBotAI ai)
			: base(ai)
		{
			base.CurrentState = EnumAIStates.ChillWithPlayer;
		}

		public ChillWithPlayerState(AIState state)
			: base(state)
		{
			base.CurrentState = EnumAIStates.ChillWithPlayer;
		}

		public override void DoAI()
		{
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_0203: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_045c: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_035f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0365: Unknown result type (might be due to invalid IL or missing references)
			EnemyAI val = base.ai.CheckLOSForEnemy(90f, 40, 5);
			if ((Object)(object)val != (Object)null)
			{
				base.ai.State = new PanikState(this, val);
				return;
			}
			bool flag = true;
			Vector3 placePosition;
			if (npcController.Npc.isInHangarShipRoom)
			{
				if (ChargeHeldItemState.HasItemToCharge(base.ai, out GrabbableObject _))
				{
					flag = false;
					base.ai.State = new ChargeHeldItemState(this, chargeAllHeldItems: true);
					return;
				}
				GrabbableObject heldItem = base.ai.HeldItem;
				int objectSlot;
				if ((Object)(object)heldItem != (Object)null && FindObject(heldItem))
				{
					flag = false;
					if (!base.ai.TurnOffHeldItem())
					{
						LethalBotAI lethalBotAI = base.ai;
						placePosition = default(Vector3);
						lethalBotAI.DropItem(placeObject: false, null, placePosition);
					}
				}
				else if (base.ai.HasGrabbableObjectInInventory((Func<GrabbableObject, bool>)FindObject, out objectSlot))
				{
					flag = false;
					base.ai.SwitchItemSlotsAndSync(objectSlot);
				}
			}
			else if (base.ai.HasSpaceInInventory())
			{
				GrabbableObject val2 = base.ai.LookingForObjectToGrab();
				if ((Object)(object)val2 != (Object)null)
				{
					base.ai.State = new FetchingObjectState(this, val2);
					return;
				}
				if (!base.ai.searchForScrap.visitInProgress && !((EnemyAI)base.ai).isOutside)
				{
					base.ai.searchForScrap.StartVisit();
				}
			}
			else if (base.ai.searchForScrap.visitInProgress)
			{
				base.ai.searchForScrap.StopSearch();
			}
			int groupId = GroupManager.Instance.GetGroupId(npcController.Npc);
			if (groupId != -1)
			{
				PlayerControllerB groupLeader = GroupManager.Instance.GetGroupLeader(groupId);
				if ((Object)(object)groupLeader != (Object)null)
				{
					if ((Object)(object)groupLeader == (Object)(object)npcController.Npc)
					{
						base.ai.State = new SearchingForScrapState(this);
						return;
					}
					if ((Object)(object)((EnemyAI)base.ai).targetPlayer != (Object)(object)groupLeader)
					{
						((EnemyAI)base.ai).targetPlayer = groupLeader;
						targetLastKnownPosition = ((Component)groupLeader).transform.position;
					}
				}
				else
				{
					GroupManager.Instance.RemoveFromCurrentGroupAndSync(npcController.Npc);
				}
			}
			if (((EnemyAI)base.ai).isOutside && (!entranceDropTimer.HasStarted() || entranceDropTimer.Elapsed()) && base.ai.HasScrapInInventory())
			{
				entranceDropTimer.Start(0.5f);
				if (LethalBotManager.Instance.LootTransferPlayers.Count <= 0 || LethalBotManager.Instance.LootTransferPlayers.Contains(NetworkBehaviourReference.op_Implicit((NetworkBehaviour)(object)((EnemyAI)base.ai).targetPlayer)))
				{
					return;
				}
				bool flag2 = false;
				EntranceTeleport[] entrancesTeleportArray = LethalBotAI.EntrancesTeleportArray;
				foreach (EntranceTeleport val3 in entrancesTeleportArray)
				{
					if (val3.isEntranceToBuilding)
					{
						placePosition = val3.entrancePoint.position - ((Component)npcController.Npc).transform.position;
						if (((Vector3)(ref placePosition)).sqrMagnitude < 400f)
						{
							flag2 = true;
							break;
						}
					}
				}
				if (flag2)
				{
					base.ai.StopMoving();
					npcController.OrderToStopSprint();
					GrabbableObject heldItem2 = base.ai.HeldItem;
					int objectSlot2;
					if ((Object)(object)heldItem2 != (Object)null && DropScrapAtEntrance(heldItem2))
					{
						LethalBotAI lethalBotAI2 = base.ai;
						placePosition = default(Vector3);
						lethalBotAI2.DropItem(placeObject: false, null, placePosition);
						LethalBotAI.DictJustDroppedItems.Remove(heldItem2);
					}
					else if (base.ai.HasGrabbableObjectInInventory((Func<GrabbableObject, bool>)DropScrapAtEntrance, out objectSlot2))
					{
						base.ai.SwitchItemSlotsAndSync(objectSlot2);
					}
				}
				return;
			}
			VehicleController vehicleCruiserTargetPlayerIsIn = base.ai.GetVehicleCruiserTargetPlayerIsIn();
			if ((Object)(object)vehicleCruiserTargetPlayerIsIn != (Object)null)
			{
				base.ai.State = new PlayerInCruiserState(this, vehicleCruiserTargetPlayerIsIn);
				return;
			}
			PlayerControllerB val4 = base.ai.LookingForPlayerToRevive();
			if ((Object)(object)val4 != (Object)null)
			{
				base.ai.State = new RescueAndReviveState(this, val4);
				return;
			}
			val4 = base.ai.LookingForPlayerToHeal();
			if ((Object)(object)val4 != (Object)null)
			{
				base.ai.State = new HealPlayerState(this, val4);
				return;
			}
			SelectBestItemFromInventory();
			PlayerControllerB val5 = base.ai.CheckLOSForTarget(90f, 40, 5);
			if ((Object)(object)val5 != (Object)null)
			{
				targetLastKnownPosition = ((Component)((EnemyAI)base.ai).targetPlayer).transform.position;
			}
			if (SqrHorizontalDistanceWithTarget > 25f || SqrVerticalDistanceWithTarget > 4f)
			{
				npcController.OrderToLookForward();
				base.ai.State = new GetCloseToPlayerState(this);
			}
			else if (LethalBotManager.IsInverseTeleporterActive && npcController.Npc.isInHangarShipRoom && flag)
			{
				base.ai.State = new UseInverseTeleporterState(this);
			}
			else
			{
				SetBotLookAt();
				base.ai.StopMoving();
				npcController.MimicEmotes(((EnemyAI)base.ai).targetPlayer);
			}
		}

		public override void TryPlayCurrentStateVoiceAudio()
		{
			base.ai.LethalBotIdentity.Voice.TryPlayVoiceAudio(new PlayVoiceParameters
			{
				VoiceState = EnumVoicesState.Chilling,
				CanTalkIfOtherLethalBotTalk = false,
				WaitForCooldown = true,
				CutCurrentVoiceStateToTalk = false,
				CanRepeatVoiceState = true,
				ShouldSync = true,
				IsLethalBotInside = npcController.Npc.isInsideFactory,
				AllowSwearing = Plugin.Config.AllowSwearing.Value
			});
		}

		public override void PlayerHeard(Vector3 noisePosition)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			SetBotLookAt(noisePosition);
		}

		public new static void RegisterChatCommands()
		{
			ChatCommandsManager.RegisterCommandForState<ChillWithPlayerState>(new ChatCommand("gear up", delegate(AIState state, LethalBotAI lethalBotAI, PlayerControllerB playerWhoSentMessage, string message, bool isVoice)
			{
				lethalBotAI.State = new GrabLoadoutState(state);
				return true;
			}));
			ChatCommandsManager.RegisterCommandForState<ChillWithPlayerState>(new ChatCommand("use key", delegate(AIState state, LethalBotAI lethalBotAI, PlayerControllerB playerWhoSentMessage, string message, bool isVoice)
			{
				//IL_0014: Unknown result type (might be due to invalid IL or missing references)
				//IL_0024: Unknown result type (might be due to invalid IL or missing references)
				//IL_0029: Unknown result type (might be due to invalid IL or missing references)
				RaycastHit val = default(RaycastHit);
				if (!lethalBotAI.HasKeyInInventory() || !Physics.Raycast(new Ray(((Component)playerWhoSentMessage.gameplayCamera).transform.position, ((Component)playerWhoSentMessage.gameplayCamera).transform.forward), ref val, 3f, 2816))
				{
					return true;
				}
				DoorLock val2 = ((Component)((RaycastHit)(ref val)).transform).GetComponent<DoorLock>();
				if ((Object)(object)val2 == (Object)null)
				{
					TriggerPointToDoor component = ((Component)((RaycastHit)(ref val)).transform).GetComponent<TriggerPointToDoor>();
					if ((Object)(object)component != (Object)null)
					{
						val2 = component.pointToDoor;
					}
				}
				if ((Object)(object)val2 != (Object)null && val2.isLocked && !val2.isPickingLock)
				{
					lethalBotAI.State = new UseKeyOnLockedDoorState(state, val2);
				}
				return true;
			}));
		}

		public new static void RegisterSignalTranslatorCommands()
		{
			SignalTranslatorCommandsManager.RegisterIgnoreDefaultForState<ChillWithPlayerState>();
		}

		private void SetBotLookAt(Vector3? position = null)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			if (Plugin.InputActionsInstance.MakeBotLookAtPosition.IsPressed())
			{
				LookAtWhatPlayerPointingAt();
				return;
			}
			if (position.HasValue)
			{
				npcController.OrderToLookAtPosition(position.Value + new Vector3(0f, 2.35f, 0f), EnumLookAtPriority.HIGH_PRIORITY, 1f);
				return;
			}
			PlayerControllerB val = base.ai.CheckLOSForClosestPlayer(90f, 5, 5);
			if ((Object)(object)val != (Object)null)
			{
				npcController.OrderToLookAtPlayer(val);
			}
			else
			{
				npcController.OrderToLookForward();
			}
		}

		private void LookAtWhatPlayerPointingAt()
		{
			//IL_0017: 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_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0132: Unknown result type (might be due to invalid IL or missing references)
			Ray val = default(Ray);
			((Ray)(ref val))..ctor(((Component)((EnemyAI)base.ai).targetPlayer.gameplayCamera).transform.position, ((Component)((EnemyAI)base.ai).targetPlayer.gameplayCamera).transform.forward);
			RaycastHit[] array = Physics.RaycastAll(val);
			if (array.Length == 0)
			{
				npcController.OrderToLookForward();
				return;
			}
			RaycastHit[] array2 = array;
			for (int i = 0; i < array2.Length; i++)
			{
				RaycastHit val2 = array2[i];
				PlayerControllerB component = ((Component)((RaycastHit)(ref val2)).collider).gameObject.GetComponent<PlayerControllerB>();
				if ((Object)(object)component != (Object)null && component.playerClientId != StartOfRound.Instance.localPlayerController.playerClientId)
				{
					npcController.OrderToLookAtPosition(((RaycastHit)(ref val2)).point, EnumLookAtPriority.HIGH_PRIORITY, ((EnemyAI)base.ai).AIIntervalTime);
					return;
				}
			}
			RaycastHit[] array3 = array;
			for (int j = 0; j < array3.Length; j++)
			{
				RaycastHit val3 = array3[j];
				if (((RaycastHit)(ref val3)).distance < 0.1f)
				{
					npcController.OrderToLookForward();
					break;
				}
				PlayerControllerB component2 = ((Component)((RaycastHit)(ref val3)).collider).gameObject.GetComponent<PlayerControllerB>();
				if (!((Object)(object)component2 != (Object)null) || component2.playerClientId != StartOfRound.Instance.localPlayerController.playerClientId)
				{
					npcController.OrderToLookAtPosition(((RaycastHit)(ref val3)).point, EnumLookAtPriority.HIGH_PRIORITY, ((EnemyAI)base.ai).AIIntervalTime);
					break;
				}
			}
		}

		protected override bool FindObject(GrabbableObject item)
		{
			if (base.ai.IsGrabbableObjectInLoadout(item) && !base.ai.HasDuplicateLoadoutItems(item, out var _))
			{
				return false;
			}
			if (!SyncedEntry<bool>.op_Implicit(Plugin.Config.DropHeldEquipmentAtShip))
			{
				return LethalBotAI.IsItemScrap(item);
			}
			return true;
		}

		protected bool DropScrapAtEntrance(GrabbableObject item)
		{
			if (LethalBotAI.IsItemScrap(item))
			{
				int objectSlot;
				if (base.ai.IsGrabbableObjectInLoadout(item))
				{
					return base.ai.HasDuplicateLoadoutItems(item, out objectSlot);
				}
				return true;
			}
			return false;
		}
	}
	public class CollectPurchasedItemsState : AIState
	{
		private float waitNoItemTimer;

		[CompilerGenerated]
		private static ItemDropship? <ItemDropship>k__BackingField;

		internal static ItemDropship? ItemDropship
		{
			get
			{
				if ((Object)(object)<ItemDropship>k__BackingField == (Object)null)
				{
					<ItemDropship>k__BackingField = Object.FindObjectOfType<ItemDropship>();
				}
				return <ItemDropship>k__BackingField;
			}
		}

		public static bool CollectDeliveredItems { get; internal set; }

		public CollectPurchasedItemsState(AIState oldState, AIState? changeToOnEnd = null)
			: base(oldState, changeToOnEnd)
		{
			base.CurrentState = EnumAIStates.CollectPurchasedItems;
		}

		public CollectPurchasedItemsState(LethalBotAI ai, AIState? changeToOnEnd = null)
			: base(ai, changeToOnEnd)
		{
			base.CurrentState = EnumAIStates.CollectPurchasedItems;
		}

		public override void DoAI()
		{
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0307: Unknown result type (might be due to invalid IL or missing references)
			//IL_0311: Unknown result type (might be due to invalid IL or missing references)
			//IL_031b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0346: Unknown result type (might be due to invalid IL or missing references)
			//IL_0338: Unknown result type (might be due to invalid IL or missing references)
			//IL_034b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0358: Unknown result type (might be due to invalid IL or missing references)
			//IL_035c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0362: Unknown result type (might be due to invalid IL or missing references)
			//IL_036a: Unknown result type (might be due to invalid IL or missing references)
			//IL_024b: Unknown result type (might be due to invalid IL or missing references)
			//IL_016a: Unknown result type (might be due to invalid IL or missing references)
			//IL_017f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0184: Unknown result type (might be due to invalid IL or missing references)
			//IL_018e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0193: Unknown result type (might be due to invalid IL or missing references)
			//IL_0198: Unknown result type (might be due to invalid IL or missing references)
			//IL_0199: Unknown result type (might be due to invalid IL or missing references)
			//IL_019e: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_020b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0210: Unknown result type (might be due to invalid IL or missing references)
			//IL_021d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0221: Unknown result type (might be due to invalid IL or missing references)
			//IL_0227: Unknown result type (might be due to invalid IL or missing references)
			//IL_022f: Unknown result type (might be due to invalid IL or missing references)
			EnemyAI val = base.ai.CheckLOSForEnemy(90f, 40, 5);
			if ((Object)(object)val != (Object)null)
			{
				base.ai.State = new PanikState(this, val);
				return;
			}
			if ((Object)(object)ItemDropship == (Object)null || !IsPossible())
			{
				ChangeBackToPreviousState();
				return;
			}
			Vector3 position = ((Component)npcController.Npc).transform.position;
			Vector3 position2 = ((Component)((Component)ItemDropship).transform.parent).gameObject.transform.position;
			Vector3 val2 = position2 - position;
			float sqrMagnitude = ((Vector3)(ref val2)).sqrMagnitude;
			val2 = ((Component)ItemDropship).transform.position - position;
			float sqrMagnitude2 = ((Vector3)(ref val2)).sqrMagnitude;
			float grabDistance = npcController.Npc.grabDistance;
			if (Mathf.Min(sqrMagnitude2, sqrMagnitude) > grabDistance * grabDistance)
			{
				if (!npcController.WaitForFullStamina && sqrMagnitude > 64f)
				{
					npcController.OrderToSprint();
				}
				else if (npcController.WaitForFullStamina || sqrMagnitude < 49f)
				{
					npcController.OrderToStopSprint();
				}
				if ((IsDropShipLanding() || IsPurchasedItemsInbound()) && !ItemDropship.shipLanded && sqrMagnitude <= 100f)
				{
					base.ai.StopMoving();
					if (sqrMagnitude < 64f)
					{
						Ray val3 = default(Ray);
						((Ray)(ref val3))..ctor(((Component)npcController.Npc).transform.position, ((Component)npcController.Npc).transform.position + Vector3.up * 0.2f - position2 + Vector3.up * 0.2f);
						((Ray)(ref val3)).direction = new Vector3(((Ray)(ref val3)).direction.x, 0f, ((Ray)(ref val3)).direction.z);
						RaycastHit val4 = default(RaycastHit);
						Vector3 val5 = ((!Physics.Raycast(val3, ref val4, 8f, StartOfRound.Instance.collidersAndRoomMaskAndDefault, (QueryTriggerInteraction)1)) ? ((Ray)(ref val3)).GetPoint(8f) : ((RaycastHit)(ref val4)).point);
						base.ai.SetDestinationToPositionLethalBotAI(RoundManager.Instance.GetNavMeshPosition(val5, default(NavMeshHit), 2.7f, -1));
						base.ai.OrderMoveToDestination();
					}
				}
				else
				{
					base.ai.SetDestinationToPositionLethalBotAI(position2);
					base.ai.OrderMoveToDestination();
				}
				return;
			}
			base.ai.StopMoving();
			if (IsDropShipLanding() || (IsPurchasedItemsInbound() && !ItemDropship.shipLanded))
			{
				if (sqrMagnitude < 64f)
				{
					Ray val6 = default(Ray);
					((Ray)(ref val6))..ctor(((Component)npcController.Npc).transform.position, ((Component)npcController.Npc).transform.position + Vector3.up * 0.2f - position2 + Vector3.up * 0.2f);
					((Ray)(ref val6)).direction = new Vector3(((Ray)(ref val6)).direction.x, 0f, ((Ray)(ref val6)).direction.z);
					RaycastHit val7 = default(RaycastHit);
					Vector3 val8 = ((!Physics.Raycast(val6, ref val7, 8f, StartOfRound.Instance.collidersAndRoomMaskAndDefault, (QueryTriggerInteraction)1)) ? ((Ray)(ref val6)).GetPoint(8f) : ((RaycastHit)(ref val7)).point);
					base.ai.SetDestinationToPositionLethalBotAI(RoundManager.Instance.GetNavMeshPosition(val8, default(NavMeshHit), 2.7f, -1));
					base.ai.OrderMoveToDestination();
				}
				return;
			}
			if (!ItemDropship.shipDoorsOpened && ItemDropship.shipLanded)
			{
				ItemDropship.triggerScript.Interact(npcController.Npc.thisPlayerBody);
				CollectDeliveredItems = true;
				return;
			}
			GrabbableObject val9 = GrabDeliveredObjects();
			if ((Object)(object)val9 == (Object)null)
			{
				if (waitNoItemTimer < 3f)
				{
					waitNoItemTimer += ((EnemyAI)base.ai).AIIntervalTime;
					return;
				}
				CollectDeliveredItems = false;
				base.ai.State = new ReturnToShipState(this);
			}
			else if (!base.ai.HasSpaceInInventory(val9))
			{
				waitNoItemTimer = 0f;
				CollectDeliveredItems = true;
				base.ai.State = new ReturnToShipState(this);
			}
			else
			{
				waitNoItemTimer = 0f;
				CollectDeliveredItems = true;
				base.ai.State = new FetchingObjectState(this, val9);
			}
		}

		public override void TryPlayCurrentStateVoiceAudio()
		{
		}

		public static bool IsPossible()
		{
			if (CollectDeliveredItems)
			{
				return true;
			}
			if (!LethalBotManager.AreWeAtTheCompanyBuilding())
			{
				return false;
			}
			if ((Object)(object)ItemDropship != (Object)null && !ItemDropship.shipDoorsOpened && (ItemDropship.shipLanded || PatchesUtil.itemsToDeliverField.Invoke(ItemDropship).Count > 0))
			{
				return true;
			}
			if (IsPurchasedItemsInbound())
			{
				return true;
			}
			return false;
		}

		public static bool IsDropShipLanding()
		{
			if ((Object)(object)ItemDropship != (Object)null && !ItemDropship.shipLanded && (ItemDropship.deliveringOrder || ItemDropship.deliveringVehicle || PatchesUtil.itemsToDeliverField.Invoke(ItemDropship).Count > 0))
			{
				return true;
			}
			return false;
		}

		public static bool IsPurchasedItemsInbound()
		{
			Terminal terminal = TerminalManager.Instance.GetTerminal();
			if ((Object)(object)terminal != (Object)null && terminal.orderedItemsFromTerminal.Count > 0)
			{
				return true;
			}
			return false;
		}

		private GrabbableObject? GrabDeliveredObjects()
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)ItemDropship == (Object)null)
			{
				return null;
			}
			Vector3 position = ((Component)((Component)ItemDropship).transform.parent).gameObject.transform.position;
			Vector3 position2 = ((Component)npcController.Npc).transform.position;
			GrabbableObject result = null;
			float num = float.MaxValue;
			for (int i = 0; i < LethalBotManager.grabbableObjectsInMap.Count; i++)
			{
				GameObject val = LethalBotManager.grabbableObjectsInMap[i];
				if ((Object)(object)val == (Object)null)
				{
					LethalBotManager.grabbableObjectsInMap.TrimExcess();
					continue;
				}
				GrabbableObject component = val.GetComponent<GrabbableObject>();
				if (!((Object)(object)component != (Object)null))
				{
					continue;
				}
				Vector3 val2 = ((Component)component).transform.position - position;
				float sqrMagnitude = ((Vector3)(ref val2)).sqrMagnitude;
				if (!(sqrMagnitude > 100f))
				{
					val2 = ((Component)component).transform.position - position2;
					sqrMagnitude = ((Vector3)(ref val2)).sqrMagnitude;
					if (sqrMagnitude < num && base.ai.IsGrabbableObjectGrabbable(component))
					{
						result = component;
						num = sqrMagnitude;
					}
				}
			}
			return result;
		}
	}
	public class CollectScrapToSellState : AIState
	{
		public CollectScrapToSellState(AIState oldState)
			: base(oldState)
		{
			base.CurrentState = EnumAIStates.CollectScrapToSell;
		}

		public override void DoAI()
		{
			if (!LethalBotManager.AreWeAtTheCompanyBuilding())
			{
				base.ai.State = new ReturnToShipState(this);
				return;
			}
			if (!base.ai.HasSpaceInInventory() || CanWeFulfillTheProfitQuota())
			{
				base.ai.State = new SellScrapState(this);
				return;
			}
			GrabbableObject val = base.ai.LookingForObjectsToSell();
			if ((Object)(object)val != (Object)null)
			{
				base.ai.State = new FetchingObjectState(this, val, EnumGrabbableObjectCall.Selling);
			}
			else if (base.ai.HasSellableItemInInventory() || LethalBotManager.AreThereItemsOnDesk())
			{
				base.ai.State = new SellScrapState(this);
			}
			else
			{
				base.ai.State = new ReturnToShipState(this);
			}
		}

		public override void TryPlayCurrentStateVoiceAudio()
		{
		}

		private bool CanWeFulfillTheProfitQuota()
		{
			TimeOfDay instance = TimeOfDay.Instance;
			if ((Object)(object)instance == (Object)null)
			{
				return false;
			}
			if (Plugin.Config.SellAllScrapOnShip.Value)
			{
				return false;
			}
			int num = instance.quotaFulfilled + LethalBotManager.GetValueOfItemsOnDesk();
			int num2 = 0;
			GrabbableObject itemOnlySlot = npcController.Npc.ItemOnlySlot;
			if ((Object)(object)itemOnlySlot != (Object)null && base.ai.IsGrabbableObjectSellable(itemOnlySlot, ignoreHeldFlag: true, skipPathCheck: true))
			{
				num2 += itemOnlySlot.scrapValue;
			}
			GrabbableObject[] itemSlots = npcController.Npc.ItemSlots;
			foreach (GrabbableObject val in itemSlots)
			{
				if ((Object)(object)val != (Object)null && base.ai.IsGrabbableObjectSellable(val, ignoreHeldFlag: true, skipPathCheck: true))
				{
					num2 += val.scrapValue;
				}
			}
			if (num + num2 >= instance.profitQuota)
			{
				return true;
			}
			return false;
		}
	}
	public class FetchingObjectState : AIState
	{
		private EnumGrabbableObjectCall enumGrabbable;

		private int grabAttempts;

		private bool ignoreEnemies;

		public FetchingObjectState(AIState state, GrabbableObject? targetItem, EnumGrabbableObjectCall enumGrabbable = EnumGrabbableObjectCall.Default, AIState? changeToOnEnd = null, bool ignoreEnemies = false)
			: base(state, changeToOnEnd)
		{
			base.CurrentState = EnumAIStates.FetchingObject;
			base.TargetItem = targetItem;
			this.enumGrabbable = enumGrabbable;
			this.ignoreEnemies = ignoreEnemies;
		}

		public override void DoAI()
		{
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0218: Unknown result type (might be due to invalid IL or missing references)
			//IL_021f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0225: Unknown result type (might be due to invalid IL or missing references)
			//IL_0238: Unknown result type (might be due to invalid IL or missing references)
			//IL_023d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0244: Unknown result type (might be due to invalid IL or missing references)
			//IL_0250: Unknown result type (might be due to invalid IL or missing references)
			//IL_02af: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_019f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a5: Unknown result type (might be due to invalid IL or missing references)
			if (!ignoreEnemies)
			{
				EnemyAI val = base.ai.CheckLOSForEnemy(90f, 40, 5);
				if ((Object)(object)val != (Object)null)
				{
					grabAttempts++;
					base.ai.State = new PanikState(this, val);
					return;
				}
			}
			if (!base.ai.HasSpaceInInventory(base.TargetItem) || (Object)(object)base.TargetItem == (Object)null || !IsObjectGrabbable() || grabAttempts > 3)
			{
				if ((Object)(object)base.TargetItem != (Object)null)
				{
					LethalBotAI.DictJustDroppedItems[base.TargetItem] = Time.realtimeSinceStartup;
				}
				base.TargetItem = null;
				ChangeBackToPreviousState();
				return;
			}
			Vector3 placePosition = ((Component)base.TargetItem).transform.position - ((Component)npcController.Npc.gameplayCamera).transform.position;
			float sqrMagnitude = ((Vector3)(ref placePosition)).sqrMagnitude;
			placePosition = ((Component)base.TargetItem).transform.position - ((Component)npcController.Npc).transform.position;
			float num = Mathf.Min(sqrMagnitude, ((Vector3)(ref placePosition)).sqrMagnitude);
			if (num < npcController.Npc.grabDistance * npcController.Npc.grabDistance && !Object.op_Implicit((Object)(object)npcController.Npc.inAnimationWithEnemy) && !npcController.Npc.activatingItem)
			{
				GrabbableObject heldItem = base.ai.HeldItem;
				if ((Object)(object)heldItem != (Object)null && heldItem.itemProperties.twoHanded)
				{
					LethalBotAI lethalBotAI = base.ai;
					placePosition = default(Vector3);
					lethalBotAI.DropItem(placeObject: false, null, placePosition);
				}
				base.ai.StopMoving();
				base.ai.GrabItemServerRpc(NetworkObjectReference.op_Implicit(((NetworkBehaviour)base.TargetItem).NetworkObject), itemGiven: false);
				if ((Object)(object)heldItem != (Object)null)
				{
					LethalBotAI.DictJustDroppedItems.Remove(heldItem);
					base.TargetItem = heldItem;
				}
				else
				{
					base.TargetItem = null;
					ChangeBackToPreviousState();
				}
				return;
			}
			SelectBestItemFromInventory();
			Vector3 navMeshPosition = RoundManager.Instance.GetNavMeshPosition(((Component)base.TargetItem).transform.position, default(NavMeshHit), npcController.Npc.grabDistance, -1);
			base.ai.SetDestinationToPositionLethalBotAI(navMeshPosition);
			if (!base.ai.IsValidPathToTarget(navMeshPosition))
			{
				DoorLock val2 = base.ai.UnlockDoorIfNeeded(200f);
				if ((Object)(object)val2 != (Object)null)
				{
					base.ai.State = new UseKeyOnLockedDoorState(this, val2);
					return;
				}
			}
			RaycastHit val3 = default(RaycastHit);
			if (!Physics.Linecast(((Component)npcController.Npc.gameplayCamera).transform.position, ((Component)base.TargetItem).transform.position + Vector3.up * 0.05f, ref val3, StartOfRound.Instance.collidersAndRoomMaskAndDefault) || (Object)(object)((Component)((RaycastHit)(ref val3)).transform).GetComponent<GrabbableObject>() == (Object)(object)base.TargetItem)
			{
				npcController.OrderToLookAtPosition(((NetworkBehaviour)base.TargetItem).NetworkObject, EnumLookAtPriority.HIGH_PRIORITY, 1f);
			}
			else
			{
				npcController.OrderToLookForward();
			}
			if (num > 64f || base.TargetItem is CaveDwellerPhysicsProp)
			{
				npcController.OrderToSprint();
			}
			else if (num < 49f)
			{
				npcController.OrderToStopSprint();
			}
			base.ai.OrderMoveToDestination();
		}

		private bool IsObjectGrabbable()
		{
			if ((Object)(object)base.TargetItem == (Object)null)
			{
				return false;
			}
			if (enumGrabbable == EnumGrabbableObjectCall.Selling)
			{
				return base.ai.IsGrabbableObjectSellable(base.TargetItem);
			}
			return base.ai.IsGrabbableObjectGrabbable(base.TargetItem, enumGrabbable);
		}

		public override void OnBotStuck()
		{
			base.OnBotStuck();
			grabAttempts++;
		}

		public override void TryPlayCurrentStateVoiceAudio()
		{
			base.ai.LethalBotIdentity.Voice.TryPlayVoiceAudio(new PlayVoiceParameters
			{
				VoiceState = EnumVoicesState.FoundLoot,
				CanTalkIfOtherLethalBotTalk = true,
				WaitForCooldown = false,
				CutCurrentVoiceStateToTalk = true,
				CanRepeatVoiceState = false,
				ShouldSync = true,
				IsLethalBotInside = npcController.Npc.isInsideFactory,
				AllowSwearing = Plugin.Config.AllowSwearing.Value
			});
		}

		public override string GetBillboardStateIndicator()
		{
			return "!!";
		}
	}
	public class FightEnemyState : AIState
	{
		[CompilerGenerated]
		private sealed class <weaponAttackCoroutine>d__24 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public FightEnemyState <>4__this;

			private CountdownTimer <attackCooldownTimer>5__2;

			private GrabbableObject <heldItem>5__3;

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

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

			[DebuggerHidden]
			public <weaponAttackCoroutine>d__24(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<attackCooldownTimer>5__2 = null;
				<heldItem>5__3 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
				//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
				int num = <>1__state;
				FightEnemyState fightEnemyState = <>4__this;
				Vector3 val;
				Vector3 targetPos;
				GrabbableObject obj;
				ShotgunItem val2;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<attackCooldownTimer>5__2 = new CountdownTimer();
					goto IL_0316;
				case 1:
					<>1__state = -1;
					goto IL_0316;
				case 2:
					<>1__state = -1;
					goto IL_0316;
				case 3:
					<>1__state = -1;
					goto IL_0316;
				case 4:
					<>1__state = -1;
					goto IL_0316;
				case 5:
					<>1__state = -1;
					goto IL_0316;
				case 6:
					<>1__state = -1;
					goto IL_0316;
				case 7:
					<>1__state = -1;
					goto IL_0316;
				case 8:
					<>1__state = -1;
					goto IL_0316;
				case 9:
					{
						<>1__state = -1;
						if (<heldItem>5__3.itemProperties.holdButtonUse)
						{
							<heldItem>5__3.UseItemOnClient(false);
						}
						goto IL_02f8;
					}
					IL_02f8:
					<attackCooldownTimer>5__2.Start(fightEnemyState.GetWeaponAttackInterval(<heldItem>5__3));
					<heldItem>5__3 = null;
					goto IL_0316;
					IL_0316:
					if (fightEnemyState.ai.State == null || fightEnemyState.ai.State != fightEnemyState || !((Object)(object)fightEnemyState.CurrentEnemy != (Object)null) || fightEnemyState.CurrentEnemy.isEnemyDead)
					{
						break;
					}
					if (fightEnemyState.ai.AreHandsFree() || !fightEnemyState.ai.IsHoldingCombatWeapon())
					{
						<>2__current = null;
						<>1__state = 1;
						return true;
					}
					<heldItem>5__3 = fightEnemyState.ai.HeldItem;
					if (!((Object)(object)fightEnemyState.EnemyCollision != (Object)null))
					{
						val = fightEnemyState.CurrentEnemy.eye.position;
					}
					else
					{
						Bounds bounds = fightEnemyState.EnemyCollision.bounds;
						val = ((Bounds)(ref bounds)).center;
					}
					targetPos = val;
					if (!fightEnemyState.CanHitEnemyWithHeldItem(<heldItem>5__3, targetPos))
					{
						fightEnemyState.canHitTarget = false;
						<>2__current = null;
						<>1__state = 2;
						return true;
					}
					fightEnemyState.canHitTarget = true;
					if (<attackCooldownTimer>5__2.HasStarted() && !<attackCooldownTimer>5__2.Elapsed())
					{
						<>2__current = null;
						<>1__state = 3;
						return true;
					}
					obj = <heldItem>5__3;
					val2 = (ShotgunItem)(object)((obj is ShotgunItem) ? obj : null);
					if (val2 != null)
					{
						if (val2.isReloading)
						{
							<>2__current = null;
							<>1__state = 4;
							return true;
						}
						if (val2.safetyOn)
						{
							((GrabbableObject)val2).ItemInteractLeftRightOnClient(false);
							<>2__current = null;
							<>1__state = 5;
							return true;
						}
						if (val2.shellsLoaded <= 0)
						{
							((GrabbableObject)val2).ItemInteractLeftRightOnClient(true);
							<>2__current = null;
							<>1__state = 6;
							return true;
						}
						<heldItem>5__3.UseItemOnClient(true);
					}
					else
					{
						GrabbableObject obj2 = <heldItem>5__3;
						PatcherTool val3 = (PatcherTool)(object)((obj2 is PatcherTool) ? obj2 : null);
						if (val3 == null)
						{
							<heldItem>5__3.UseItemOnClient(true);
							<>2__current = null;
							<>1__state = 9;
							return true;
						}
						Transform shockingTarget = fightEnemyState.npcController.Npc.shockingTarget;
						if (val3.isShocking)
						{
							IShockableWithGun componentInChildren = ((Component)((Component)fightEnemyState.CurrentEnemy).transform).GetComponentInChildren<IShockableWithGun>();
							Plugin.LogDebug($"Shocking Target: {shockingTarget}, Current Enemy Shockable: {((componentInChildren != null) ? componentInChildren.GetShockableTransform() : null)}");
							if ((Object)(object)shockingTarget == (Object)(object)((componentInChildren != null) ? componentInChildren.GetShockableTransform() : null))
							{
								<>2__current = null;
								<>1__state = 7;
								return true;
							}
							<heldItem>5__3.UseItemOnClient(true);
							<>2__current = null;
							<>1__state = 8;
							return true;
						}
						if (!isScanning.Invoke(val3))
						{
							<heldItem>5__3.UseItemOnClient(true);
						}
					}
					goto IL_02f8;
				}
				fightEnemyState.StopAttackCoroutine();
				return false;
			}

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

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

		private static readonly FieldRef<KnifeItem, int> knifeMask = (FieldRef<KnifeItem, int>)(object)AccessTools.FieldRefAccess<int>(typeof(KnifeItem), "knifeMask");

		private static readonly FieldRef<Shovel, int> shovelMask = (FieldRef<Shovel, int>)(object)AccessTools.FieldRefAccess<int>(typeof(Shovel), "shovelMask");

		private static readonly FieldRef<PatcherTool, bool> isScanning = (FieldRef<PatcherTool, bool>)(object)AccessTools.FieldRefAccess<bool>(typeof(PatcherTool), "isScanning");

		private static readonly FieldRef<PatcherTool, int> anomalyMask = (FieldRef<PatcherTool, int>)(object)AccessTools.FieldRefAccess<int>(typeof(PatcherTool), "anomalyMask");

		private float attackFOV;

		private bool canHitTarget;

		private RaycastHit[] enemyColliders;

		private Coroutine? currentAttackRoutine;

		private Collider? _enemyCollision;

		private EnemyAI? _lastEnemy;

		private float lastColliderUpdateTimer;

		private Collider? EnemyCollision
		{
			get
			{
				//IL_003d: Unknown result type (might be due to invalid IL or missing references)
				if ((Object)(object)_lastEnemy != (Object)(object)base.CurrentEnemy || Time.timeSinceLevelLoad - lastColliderUpdateTimer > 2f)
				{
					_enemyCollision = FindEnemyCollider(base.CurrentEnemy, ((Component)npcController.Npc).transform.position);
					_lastEnemy = base.CurrentEnemy;
					lastColliderUpdateTimer = Time.timeSinceLevelLoad;
					Plugin.LogDebug($"Enemy: {base.CurrentEnemy} Enemy Collider: {_enemyCollision}");
				}
				return _enemyCollision;
			}
		}

		public FightEnemyState(AIState oldState, EnemyAI enemyAI, AIState? changeToOnEnd = null)
			: base(oldState, changeToOnEnd)
		{
			base.CurrentState = EnumAIStates.FightEnemy;
			base.CurrentEnemy = enemyAI;
		}

		public override void OnEnterState()
		{
			if (!hasBeenStarted)
			{
				if ((Object)(object)base.CurrentEnemy == (Object)null || base.CurrentEnemy.isEnemyDead)
				{
					Plugin.LogWarning("FightEnemyState: CurrentEnemy is null or dead, cannot start the state!");
					ChangeBackToPreviousState();
					return;
				}
				if (!base.ai.GetFearRangeForEnemies(base.CurrentEnemy).HasValue || !base.ai.CanEnemyBeKilled(base.CurrentEnemy, (Object)(object)LethalBotManager.Instance.MissionControlPlayer == (Object)(object)npcController.Npc) || !base.ai.HasCombatWeapon())
				{
					ChangeBackToPreviousState();
					return;
				}
				canHitTarget = false;
				StartAttackCoroutine();
			}
			base.OnEnterState();
		}

		public override void OnExitState(AIState newState)
		{
			GrabbableObject? heldItem = base.ai.HeldItem;
			PatcherTool val = (PatcherTool)(object)((heldItem is PatcherTool) ? heldItem : null);
			if (val != null && val.isShocking)
			{
				((GrabbableObject)val).UseItemOnClient(true);
			}
			base.OnExitState(newState);
		}

		public override void DoAI()
		{
			//IL_01bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0205: Unknown result type (might be due to invalid IL or missing references)
			//IL_020a: Unknown result type (might be due to invalid IL or missing references)
			//IL_020e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0213: Unknown result type (might be due to invalid IL or missing references)
			//IL_0228: Unknown result type (might be due to invalid IL or missing references)
			//IL_023d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0242: Unknown result type (might be due to invalid IL or missing references)
			//IL_0247: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_02af: Unknown result type (might be due to invalid IL or missing references)
			//IL_0299: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02db: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0441: Unknown result type (might be due to invalid IL or missing references)
			//IL_0462: Unknown result type (might be due to invalid IL or missing references)
			//IL_0494: Unknown result type (might be due to invalid IL or missing references)
			//IL_0499: Unknown result type (might be due to invalid IL or missing references)
			//IL_049b: Unknown result type (might be due to invalid IL or missing references)
			//IL_04a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_04aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0331: Unknown result type (might be due to invalid IL or missing references)
			//IL_0346: Unknown result type (might be due to invalid IL or missing references)
			//IL_034b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0355: Unknown result type (might be due to invalid IL or missing references)
			//IL_035a: Unknown result type (might be due to invalid IL or missing references)
			//IL_036a: Unknown result type (might be due to invalid IL or missing references)
			//IL_036f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0374: Unknown result type (might be due to invalid IL or missing references)
			//IL_037e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0383: Unknown result type (might be due to invalid IL or missing references)
			//IL_0391: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_03db: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_03eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_03fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0406: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)base.CurrentEnemy == (Object)null || base.CurrentEnemy.isEnemyDead)
			{
				ChangeBackToPreviousState();
				return;
			}
			if (!base.ai.CanEnemyBeKilled(base.CurrentEnemy, (Object)(object)LethalBotManager.Instance.MissionControlPlayer == (Object)(object)npcController.Npc) || !base.ai.HasCombatWeapon())
			{
				ChangeBackToPreviousState();
				return;
			}
			float? num = base.ai.GetFearRangeForEnemies(base.CurrentEnemy);
			if (!num.HasValue)
			{
				ChangeBackToPreviousState();
				return;
			}
			EnemyAI val = base.ai.CheckLOSForEnemy(90f, 40, 5);
			if ((Object)(object)val != (Object)null && (Object)(object)val != (Object)(object)base.CurrentEnemy)
			{
				float? fearRangeForEnemies = base.ai.GetFearRangeForEnemies(val);
				if (fearRangeForEnemies.HasValue && base.ai.CanEnemyBeKilled(val, (Object)(object)LethalBotManager.Instance.MissionControlPlayer == (Object)(object)npcController.Npc))
				{
					base.CurrentEnemy = val;
					num = fearRangeForEnemies.Value;
				}
			}
			if (!base.ai.TryFindItemInInventory(FindObject, FindBetterObject, out var objectSlot))
			{
				Plugin.LogWarning("Bot " + npcController.Npc.playerUsername + " didn't have a weapon despite HasCombatWeapon telling us we did!");
				ChangeBackToPreviousState();
				return;
			}
			if (Plugin.IsModLethalPhonesLoaded)
			{
				base.ai.HangupPhone();
			}
			Vector3 placePosition;
			if (npcController.Npc.currentItemSlot != objectSlot || !base.ai.IsHoldingCombatWeapon())
			{
				GrabbableObject heldItem = base.ai.HeldItem;
				if ((Object)(object)heldItem != (Object)null && heldItem.itemProperties.twoHanded)
				{
					LethalBotAI lethalBotAI = base.ai;
					placePosition = default(Vector3);
					lethalBotAI.DropItem(placeObject: false, null, placePosition);
					LethalBotAI.DictJustDroppedItems.Remove(heldItem);
				}
				else
				{
					base.ai.SwitchItemSlotsAndSync(objectSlot);
				}
				return;
			}
			StartAttackCoroutine();
			float num2;
			Bounds bounds;
			if (!((Object)(object)EnemyCollision != (Object)null))
			{
				num2 = 0.4f;
			}
			else
			{
				bounds = EnemyCollision.bounds;
				placePosition = ((Bounds)(ref bounds)).extents;
				num2 = ((Vector3)(ref placePosition)).magnitude;
			}
			float num3 = num2;
			placePosition = ((Component)base.CurrentEnemy).transform.position - ((Component)npcController.Npc).transform.position;
			float sqrMagnitude = ((Vector3)(ref placePosition)).sqrMagnitude;
			float num4 = GetAttackRangeForWeapon(base.ai.HeldItem) + num3;
			float num5 = num4 * 0.75f;
			float num6 = num.Value * 1.5f;
			Vector3 val2;
			if (!((Object)(object)EnemyCollision != (Object)null))
			{
				val2 = base.CurrentEnemy.eye.position;
			}
			else
			{
				bounds = EnemyCollision.bounds;
				val2 = ((Bounds)(ref bounds)).center;
			}
			Vector3 val3 = val2;
			Vector3 navMeshPosition = RoundManager.Instance.GetNavMeshPosition(((Component)base.CurrentEnemy).transform.position, default(NavMeshHit), 2.7f, -1);
			if (sqrMagnitude < num4 * num4 && canHitTarget)
			{
				if (!Object.op_Implicit((Object)(object)npcController.Npc.inAnimationWithEnemy))
				{
					if (sqrMagnitude < num5 * num5)
					{
						Ray val4 = default(Ray);
						((Ray)(ref val4))..ctor(((Component)npcController.Npc).transform.position, ((Component)npcController.Npc).transform.position + Vector3.up * 0.2f - ((Component)base.CurrentEnemy).transform.position + Vector3.up * 0.2f);
						((Ray)(ref val4)).direction = new Vector3(((Ray)(ref val4)).direction.x, 0f, ((Ray)(ref val4)).direction.z);
						RaycastHit val5 = default(RaycastHit);
						Vector3 val6 = ((!Physics.Raycast(val4, ref val5, num4, StartOfRound.Instance.collidersAndRoomMaskAndDefault, (QueryTriggerInteraction)1)) ? ((Ray)(ref val4)).GetPoint(num4) : ((RaycastHit)(ref val5)).point);
						Vector3 navMeshPosition2 = RoundManager.Instance.GetNavMeshPosition(val6, default(NavMeshHit), 2.7f, -1);
						base.ai.SetDestinationToPositionLethalBotAI(navMeshPosition2);
						npcController.OrderToSprint();
						base.ai.OrderMoveToDestination();
					}
					else
					{
						base.ai.StopMoving();
					}
				}
			}
			else
			{
				if (sqrMagnitude > num6 * num6 || !base.ai.IsValidPathToTarget(navMeshPosition))
				{
					ChangeBackToPreviousState();
					return;
				}
				base.ai.SetDestinationToPositionLethalBotAI(navMeshPosition);
				npcController.OrderToSprint();
				base.ai.OrderMoveToDestination();
			}
			RaycastHit val7 = default(RaycastHit);
			if (!Physics.Linecast(((Component)npcController.Npc.gameplayCamera).transform.position, val3 + Vector3.up * 0.2f, ref val7, StartOfRound.Instance.collidersAndRoomMaskAndDefault) || (Object)(object)((Component)((RaycastHit)(ref val7)).collider).gameObject.GetComponentInParent<EnemyAI>() == (Object)(object)base.CurrentEnemy)
			{
				npcController.OrderToLookAtPosition(((NetworkBehaviour)base.CurrentEnemy).NetworkObject, EnumLookAtPriority.HIGH_PRIORITY, 1f, bypassSteadyCheck: true, attackFOV);
			}
			else
			{
				npcController.OrderToLookForward();
			}
		}

		public override void UseHeldItem()
		{
			GrabbableObject heldItem = base.ai.HeldItem;
			if ((Object)(object)heldItem == (Object)null || !base.ai.CanUseHeldItem() || LethalBotAI.IsItemWeapon(heldItem))
			{
				return;
			}
			WalkieTalkie val = (WalkieTalkie)(object)((heldItem is WalkieTalkie) ? heldItem : null);
			if (val != null)
			{
				if (((GrabbableObject)val).isBeingUsed && val.isHoldingButton)
				{
					((GrabbableObject)val).UseItemOnClient(false);
				}
			}
			else
			{
				base.UseHeldItem();
			}
		}

		public override void StopAllCoroutines()
		{
			base.StopAllCoroutines();
			StopAttackCoroutine();
		}

		public override void TryPlayCurrentStateVoiceAudio()
		{
			if (!base.ai.AreHandsFree() && base.ai.IsHoldingCombatWeapon())
			{
				EnumVoicesState enumVoicesState = (base.ai.IsHoldingRangedWeapon() ? EnumVoicesState.AttackingWithGun : EnumVoicesState.AttackingWithMelee);
				base.ai.LethalBotIdentity.Voice.TryPlayVoiceAudio(new PlayVoiceParameters
				{
					VoiceState = enumVoicesState,
					CanTalkIfOtherLethalBotTalk = true,
					WaitForCooldown = (base.ai.LethalBotIdentity.Voice.LastVoiceState == enumVoicesState),
					CutCurrentVoiceStateToTalk = true,
					CanRepeatVoiceState = true,
					ShouldSync = true,
					IsLethalBotInside = npcController.Npc.isInsideFactory,
					AllowSwearing = Plugin.Config.AllowSwearing.Value
				});
			}
		}

		public new static void RegisterSignalTranslatorCommands()
		{
			SignalTranslatorCommandsManager.RegisterCommandForState<FightEnemyState>(new SignalTranslatorCommand("return", delegate(AIState state, LethalBotAI lethalBotAI, string message)
			{
				FightEnemyState fightEnemyState = (FightEnemyState)state;
				if ((Object)(object)state.CurrentEnemy != (Object)null && (Object)(object)state.CurrentEnemy.targetPlayer != (Object)(object)lethalBotAI.NpcController.Npc)
				{
					lethalBotAI.State = new ReturnToShipState(state);
					return true;
				}
				fightEnemyState.previousAIState = new ReturnToShipState(state);
				return true;
			}));
		}

		public override bool? ShouldBotCrouch()
		{
			return false;
		}

		protected override void ChangeBackToPreviousState()
		{
			GrabbableObject heldItem = base.ai.HeldItem;
			if ((Object)(object)heldItem != (Object)null)
			{
				ShotgunItem val = (ShotgunItem)(object)((heldItem is ShotgunItem) ? heldItem : null);
				if (val != null && !val.safetyOn)
				{
					((GrabbableObject)val).ItemInteractLeftRightOnClient(false);
				}
			}
			if ((base.previousState.GetValueOrDefault() == EnumAIStates.SearchingForScrap || (base.previousState.GetValueOrDefault() == EnumAIStates.FetchingObject && !base.ai.IsFollowingTargetPlayer())) && base.ai.HasScrapInInventory())
			{
				bool flag = true;
				if (LethalBotManager.Instance.LootTransferPlayers.Count > 0)
				{
					flag = false;
				}
				base.ai.State = new ReturnToShipState(this, !flag, new SearchingForScrapState(this));
			}
			else
			{
				base.ChangeBackToPreviousState();
			}
		}

		private static Collider? FindEnemyCollider(EnemyAI? CurrentEnemy, Vector3 ourPos)
		{
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			Collider val = null;
			float num = float.MaxValue;
			if ((Object)(object)CurrentEnemy != (Object)null)
			{
				Plugin.LogDebug("Attempting to get the enemy collider!");
				Collider[] componentsInChildren = ((Component)CurrentEnemy).gameObject.GetComponentsInChildren<Collider>();
				Collider[] array = componentsInChildren;
				foreach (Collider val2 in array)
				{
					ScanNodeProperties val3 = ((val2 != null) ? ((Component)((Component)val2).transform).gameObject.GetComponent<ScanNodeProperties>() : null);
					if ((Object)(object)val2 != (Object)null && (Object)(object)val3 == (Object)null)
					{
						Vector3 val4 = val2.ClosestPoint(ourPos);
						Vector3 val5 = val4 - ourPos;
						float sqrMagnitude = ((Vector3)(ref val5)).sqrMagnitude;
						if ((Object)(object)val == (Object)null || sqrMagnitude < num)
						{
							val = val2;
							num = sqrMagnitude;
						}
					}
				}
				Plugin.LogDebug((((Object)(object)val != (Object)null) ? "Found" : "Not Found") ?? "");
				return val;
			}
			return null;
		}

		[IteratorStateMachine(typeof(<weaponAttackCoroutine>d__24))]
		private IEnumerator weaponAttackCoroutine()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <weaponAttackCoroutine>d__24(0)
			{
				<>4__this = this
			};
		}

		private bool CanHitEnemyWithHeldItem(GrabbableObject heldItem, Vector3 targetPos)
		{
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)base.CurrentEnemy == (Object)null)
			{
				return false;
			}
			PlayerControllerB npc = npcController.Npc;
			EnemyAI? currentEnemy = base.CurrentEnemy;
			BushWolfEnemy val = (BushWolfEnemy)(object)((currentEnemy is BushWolfEnemy) ? currentEnemy : null);
			if (val != null && (Object)(object)val.draggingPlayer == (Object)(object)npc && !LethalBotAI.IsItemRangedWeapon(heldItem))
			{
				return true;
			}
			Vector3 val2 = targetPos - ((Component)npc.gameplayCamera).transform.position;
			float num = Vector3.Angle(npc.playerEye.forward, val2);
			if (enemyColliders == null)
			{
				enemyColliders = (RaycastHit[])(object)new RaycastHit[10];
			}
			GetWeaponAttackInfo(heldItem, npc, out var ray, out var maxFOV, out var radius, out var maxRange, out var hitMask);
			attackFOV = Mathf.Clamp(maxFOV, 0f, 90f);
			if (num < maxFOV)
			{
				if (heldItem is PatcherTool)
				{
					return CanHitPatcherTool(npc, targetPos, ray, radius, maxRange, hitMask);
				}
				if (LethalBotAI.IsItemRangedWeapon(heldItem))
				{
					return CanHitRangedWeapon(npc, ray, radius, maxRange, hitMask);
				}
				return CanHitMeleeWeapon(npc, ray, radius, maxRange, hitMask);
			}
			return false;
		}

		private bool CanHitRangedWeapon(PlayerControllerB lethalBotController, Ray ray, float radius, float maxRange, LayerMask hitMask)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			int num = Physics.SphereCastNonAlloc(ray, radius, enemyColliders, maxRange, LayerMask.op_Implicit(hitMask), (QueryTriggerInteraction)2);
			IHittable val2 = default(IHittable);
			for (int i = 0; i < num; i++)
			{
				RaycastHit val = enemyColliders[i];
				if (((RaycastHit)(ref val)).distance == 0f || ((RaycastHit)(ref val)).point == Vector3.zero || !((Component)((RaycastHit)(ref val)).transform).TryGetComponent<IHittable>(ref val2) || Physics.Linecast(((Component)lethalBotController.gameplayCamera).transform.position, ((RaycastHit)(ref val)).point, StartOfRound.Instance.collidersAndRoomMaskAndDefault, (QueryTriggerInteraction)1))
				{
					continue;
				}
				if (!((Object)(object)((RaycastHit)(ref val)).collider == (Object)(object)EnemyCollision))
				{
					EnemyAI val3 = ((Component)((RaycastHit)(ref val)).transform).gameObject.GetComponent<EnemyAICollisionDetect>()?.mainScript;
					if (val3 == null || !((Object)(object)val3 == (Object)(object)base.CurrentEnemy))
					{
						continue;
					}
				}
				return true;
			}
			return false;
		}

		private bool CanHitPatcherTool(PlayerControllerB lethalBotController, Vector3 targetPos, Ray ray, float radius, float maxRange, LayerMask hitMask)
		{
			//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_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: 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)
			if (enemyColliders == null)
			{
				enemyColliders = (RaycastHit[])(object)new RaycastHit[10];
			}
			if (Physics.Linecast(((Component)lethalBotController.gameplayCamera).transform.position, targetPos, StartOfRound.Instance.collidersAndRoomMaskAndDefault))
			{
				return false;
			}
			int num = Physics.SphereCastNonAlloc(ray, radius, enemyColliders, maxRange, LayerMask.op_Implicit(hitMask), (QueryTriggerInteraction)2);
			int num2 = 0;
			while (num2 < num)
			{
				RaycastHit val = enemyColliders[num2];
				if (!((Object)(object)((RaycastHit)(ref val)).collider == (Object)(object)EnemyCollision))
				{
					EnemyAI componentInParent = ((Component)((RaycastHit)(ref val)).collider).gameObject.GetComponentInParent<EnemyAI>();
					if (componentInParent == null || !((Object)(object)componentInParent == (Object)(object)base.CurrentEnemy))
					{
						num2++;
						continue;
					}
				}
				return true;
			}
			return false;
		}

		private bool CanHitMeleeWeapon(PlayerControllerB lethalBotController, Ray ray, float radius, float maxRange, LayerMask hitMask)
		{
			//IL_0000: 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_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0139: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			RaycastHit[] array = Physics.SphereCastAll(ray, radius, maxRange, LayerMask.op_Implicit(hitMask), (QueryTriggerInteraction)2);
			List<RaycastHit> list = array.OrderBy((RaycastHit x) => ((RaycastHit)(ref x)).distance).ToList();
			RaycastHit[] array2 = array;
			IHittable val3 = default(IHittable);
			RaycastHit val4 = default(RaycastHit);
			for (int i = 0; i < array2.Length; i++)
			{
				RaycastHit val = array2[i];
				if (((Component)((RaycastHit)(ref val)).transform).gameObject.layer == 8 || ((Component)((RaycastHit)(ref val)).transform).gameObject.layer == 11)
				{
					if (((RaycastHit)(ref val)).collider.isTrigger)
					{
						continue;
					}
					string tag = ((Component)((RaycastHit)(ref val)).collider).gameObject.tag;
					FootstepSurface[] footstepSurfaces = StartOfRound.Instance.footstepSurfaces;
					foreach (FootstepSurface val2 in footstepSurfaces)
					{
						if (val2.surfaceTag == tag)
						{
							break;
						}
					}
				}
				else if (((Component)((RaycastHit)(ref val)).transform).TryGetComponent<IHittable>(ref val3) && (!(((RaycastHit)(ref val)).point != Vector3.zero) || !Physics.Linecast(((Component)lethalBotController.gameplayCamera).transform.position, ((RaycastHit)(ref val)).point, ref val4, StartOfRound.Instance.collidersAndRoomMaskAndDefault, (QueryTriggerInteraction)1)))
				{
					Vector3 forward = ((Component)lethalBotController.gameplayCamera).transform.forward;
					EnemyAICollisionDetect component = ((Component)((RaycastHit)(ref val)).transform).GetComponent<EnemyAICollisionDetect>();
					bool flag = (Object)(object)((Component)((RaycastHit)(ref val)).transform).GetComponent<PlayerControllerB>() != (Object)null;
					if (((Object)(object)component != (Object)null || !flag) && (!flag || ((Object)(object)component?.mainScript != (Object)null && (!StartOfRound.Instance.hangarDoorsClosed || component.mainScript.isInsidePlayerShip == lethalBotController.isInHangarShipRoom))) && ((Object)(object)((RaycastHit)(ref val)).collider == (Object)(object)EnemyCollision || ((Object)(object)component != (Object)null && (Object)(object)component == (Object)(object)base.CurrentEnemy)))
					{
						return true;
					}
				}
			}
			return false;
		}

		private float GetAttackRangeForWeapon(GrabbableObject? weapon)
		{
			if ((Object)(object)weapon == (Object)null)
			{
				return 2f;
			}
			if (weapon is ShotgunItem)
			{
				return 4f;
			}
			if (weapon is PatcherTool)
			{
				return 5f;
			}
			if (weapon is KnifeItem)
			{
				return 1f;
			}
			if (LethalBotAI.IsItemRangedWeapon(weapon))
			{
				return 5f;
			}
			return 2f;
		}

		private float GetWeaponAttackInterval(GrabbableObject? weapon)
		{
			if (!LethalBotAI.IsItemWeapon(weapon))
			{
				if (!((Object)(object)weapon != (Object)null) || !(weapon.useCooldown > 0f))
				{
					return 0f;
				}
				return weapon.useCooldown;
			}
			if (LethalBotAI.IsItemRangedWeapon(weapon))
			{
				return 0.1f;
			}
			if (weapon is KnifeItem)
			{
				return 0.43f;
			}
			return 0.78f;
		}

		private void GetWeaponAttackInfo(GrabbableObject? weapon, PlayerControllerB lethalBotController, out Ray ray, out float maxFOV, out float radius, out float maxRange, out LayerMask hitMask)
		{
			//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_003a: 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_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			//IL_011d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_0128: Unknown result type (might be due to invalid IL or missing references)
			//IL_012d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0132: Unknown result type (might be due to invalid IL or missing references)
			//IL_0133: Unknown result type (might be due to invalid IL or missing references)
			//IL_0138: Unknown result type (might be due to invalid IL or missing references)
			//IL_0163: Unknown result type (might be due to invalid IL or missing references)
			//IL_0168: Unknown result type (might be due to invalid IL or missing references)
			//IL_0186: Unknown result type (might be due to invalid IL or missing references)
			//IL_0196: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_01eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_020e: Unknown result type (might be due to invalid IL or missing references)
			//IL_021e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0228: Unknown result type (might be due to invalid IL or missing references)
			//IL_022d: Unknown result type (might be due to invalid IL or missing references)
			//IL_023d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0242: Unknown result type (might be due to invalid IL or missing references)
			//IL_0247: Unknown result type (might be due to invalid IL or missing references)
			//IL_0273: Unknown result type (might be due to invalid IL or missing references)
			//IL_0278: Unknown result type (might be due to invalid IL or missing references)
			maxFOV = 60f;
			radius = 5f;
			maxRange = 15f;
			hitMask = LayerMask.op_Implicit(StartOfRound.Instance.collidersAndRoomMaskAndDefault);
			ray = new Ray(((Component)lethalBotController.gameplayCamera).transform.position, ((Component)lethalBotController.gameplayCamera).transform.forward);
			if ((Object)(object)weapon == (Object)null)
			{
				return;
			}
			if (weapon is ShotgunItem)
			{
				Vector3 val = ((Component)lethalBotController.gameplayCamera).transform.position - ((Component)lethalBotController.gameplayCamera).transform.up * 0.45f;
				Vector3 forward = ((Component)lethalBotController.gameplayCamera).transform.forward;
				ray = new Ray(val - forward * 10f, forward);
				maxFOV = 30f;
				radius = 5f;
				maxRange = 15f;
				hitMask = LayerMask.op_Implicit(524288);
				return;
			}
			PatcherTool val2 = (PatcherTool)(object)((weapon is PatcherTool) ? weapon : null);
			if (val2 != null)
			{
				Vector3 forward2 = ((Component)lethalBotController.gameplayCamera).transform.forward;
				ray = new Ray(((Component)lethalBotController.gameplayCamera).transform.position - forward2 * 3f, forward2);
				maxFOV = 60f;
				radius = 5f;
				maxRange = 5f;
				hitMask = LayerMask.op_Implicit(anomalyMask.Invoke(val2));
				return;
			}
			KnifeItem val3 = (KnifeItem)(object)((weapon is KnifeItem) ? weapon : null);
			if (val3 != null)
			{
				ray = new Ray(((Component)lethalBotController.gameplayCamera).transform.position + ((Component)lethalBotController.gameplayCamera).transform.right * 0.1f, ((Component)lethalBotController.gameplayCamera).transform.forward);
				maxFOV = 45f;
				radius = 0.3f;
				maxRange = 0.75f;
				hitMask = LayerMask.op_Implicit(knifeMask.Invoke(val3));
				return;
			}
			Shovel val4 = (Shovel)(object)((weapon is Shovel) ? weapon : null);
			if (val4 != null)
			{
				ray = new Ray(((Component)lethalBotController.gameplayCamera).transform.position + ((Component)lethalBotController.gameplayCamera).transform.right * -0.35f, ((Component)lethalBotController.gameplayCamera).transform.forward);
				maxFOV = 75f;
				radius = 0.8f;
				maxRange = 1.5f;
				hitMask = LayerMask.op_Implicit(shovelMask.Invoke(val4));
			}
		}

		public override Vector3? SelectSubjectTargetPoint(LookAtTarget lookAtTarget, NetworkObject? subject, PlayerControllerB ourController)
		{
			//IL_0028: 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_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)
			EnemyAI val = default(EnemyAI);
			if ((Object)(object)subject != (Object)null && ((Component)subject).TryGetComponent<EnemyAI>(ref val))
			{
				Collider val2 = (((Object)(object)val == (Object)(object)base.CurrentEnemy) ? EnemyCollision : FindEnemyCollider(val, ((Component)ourController).transform.position));
				if ((Object)(object)val2 != (Object)null)
				{
					Bounds bounds = val2.bounds;
					return ((Bounds)(ref bounds)).center;
				}
			}
			return base.SelectSubjectTargetPoint(lookAtTarget, subject, ourController);
		}

		protected override bool FindObject(GrabbableObject item)
		{
			return base.ai.HasAmmoForWeapon(item);
		}

		protected override bool FindBetterObject(GrabbableObject currentBest, GrabbableObject canidate)
		{
			bool flag = LethalBotAI.IsItemRangedWeapon(currentBest);
			bool flag2 = LethalBotAI.IsItemRangedWeapon(canidate);
			if (base.CurrentEnemy is CentipedeAI)
			{
				if (flag && !flag2)
				{
					return true;
				}
				return false;
			}
			if (!flag && flag2)
			{
				return true;
			}
			return false;
		}

		private void StartAttackCoroutine()
		{
			if (currentAttackRoutine == null)
			{
				currentAttackRoutine = ((MonoBehaviour)base.ai).StartCoroutine(weaponAttackCoroutine());
			}
		}

		private void StopAttackCoroutine()
		{
			if (currentAttackRoutine != null)
			{
				((MonoBehaviour)base.ai).StopCoroutine(currentAttackRoutine);
				currentAttackRoutine = null;
			}
		}
	}
	public class GetCloseToPlayerState : AIState
	{
		public GetCloseToPlayerState(AIState state)
			: base(state)
		{
			base.CurrentState = EnumAIStates.GetCloseToPlayer;
		}

		public GetCloseToPlayerState(LethalBotAI ai)
			: base(ai)
		{
			base.CurrentState = EnumAIStates.GetCloseToPlayer;
		}

		public GetCloseToPlayerState(LethalBotAI ai, PlayerControllerB targetPlayer)
			: this(ai)
		{
			((EnemyAI)ai).targetPlayer = targetPlayer;
		}

		public GetCloseToPlayerState(AIState state, PlayerControllerB targetPlayer)
			: this(state)
		{
			((EnemyAI)base.ai).targetPlayer = targetPlayer;
		}

		public override void OnEnterState()
		{
			//IL_0015: 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)
			if (LethalBotManager.Instance.LootTransferPlayers.Contains(NetworkBehaviourReference.op_Implicit((NetworkBehaviour)(object)npcController.Npc)))
			{
				LethalBotManager.Instance.RemovePlayerFromLootTransferListAndSync(NetworkBehaviourReference.op_Implicit((NetworkBehaviour)(object)npcController.Npc));
			}
			base.OnEnterState();
		}

		public override void DoAI()
		{
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_030f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0314: Unknown result type (might be due to invalid IL or missing references)
			//IL_0319: Unknown result type (might be due to invalid IL or missing references)
			//IL_0324: Unknown result type (might be due to invalid IL or missing references)
			//IL_0336: Unknown result type (might be due to invalid IL or missing references)
			//IL_033b: Unknown result type (might be due to invalid IL or missing references)
			//IL_034f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0354: Unknown result type (might be due to invalid IL or missing references)
			//IL_0359: Unknown result type (might be due to invalid IL or missing references)
			//IL_04e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_037d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0521: Unknown result type (might be due to invalid IL or missing references)
			//IL_03bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_05bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_05c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0451: Unknown result type (might be due to invalid IL or missing references)
			//IL_0457: Unknown result type (might be due to invalid IL or missing references)
			EnemyAI val = base.ai.CheckLOSForEnemy(90f, 40, 5);
			if ((Object)(object)val != (Object)null)
			{
				base.ai.State = new PanikState(this, val);
				return;
			}
			StartOfRound instance = StartOfRound.Instance;
			if ((npcController.Npc.isInElevator || npcController.Npc.isInHangarShipRoom) && !LethalBotManager.AreWeInOrbit(instance) && (LethalBotManager.IsTheShipLeaving(instance) || !LethalBotManager.IsTheShipLanded(instance)))
			{
				return;
			}
			int groupId = GroupManager.Instance.GetGroupId(npcController.Npc);
			if (groupId != -1)
			{
				PlayerControllerB groupLeader = GroupManager.Instance.GetGroupLeader(groupId);
				if ((Object)(object)groupLeader != (Object)null)
				{
					if ((Object)(object)groupLeader == (Object)(object)npcController.Npc)
					{
						base.ai.State = new SearchingForScrapState(this);
						return;
					}
					if ((Object)(object)((EnemyAI)base.ai).targetPlayer != (Object)(object)groupLeader)
					{
						((EnemyAI)base.ai).targetPlayer = groupLeader;
						targetLastKnownPosition = ((Component)groupLeader).transform.position;
					}
				}
				else
				{
					GroupManager.Instance.RemoveFromCurrentGroupAndSync(npcController.Npc);
				}
			}
			if ((Object)(object)((EnemyAI)base.ai).targetPlayer == (Object)null)
			{
				if (targetLastKnownPosition.HasValue)
				{
					base.ai.State = new JustLostPlayerState(this);
				}
				else
				{
					base.ai.State = new SearchingForPlayerState(this);
				}
				return;
			}
			if (!((EnemyAI)base.ai).PlayerIsTargetable(((EnemyAI)base.ai).targetPlayer, false, true, false))
			{
				base.ai.State = new SearchingForPlayerState(this);
				return;
			}
			VehicleController vehicleCruiserTargetPlayerIsIn = base.ai.GetVehicleCruiserTargetPlayerIsIn();
			if ((Object)(object)vehicleCruiserTargetPlayerIsIn != (Object)null)
			{
				base.ai.State = new PlayerInCruiserState(this, vehicleCruiserTargetPlayerIsIn);
				return;
			}
			PlayerControllerB val2 = base.ai.LookingForPlayerToRevive();
			if ((Object)(object)val2 != (Object)null)
			{
				base.ai.State = new RescueAndReviveState(this, val2);
				return;
			}
			val2 = base.ai.LookingForPlayerToHeal();
			if ((Object)(object)val2 != (Object)null)
			{
				base.ai.State = new HealPlayerState(this, val2);
				return;
			}
			if (base.ai.HasSpaceInInventory())
			{
				GrabbableObject val3 = base.ai.LookingForObjectToGrab();
				if ((Object)(object)val3 != (Object)null)
				{
					base.ai.State = new FetchingObjectState(this, val3);
					return;
				}
				if (!base.ai.searchForScrap.visitInProgress && !((EnemyAI)base.ai).isOutside)
				{
					base.ai.searchForScrap.StartVisit();
				}
			}
			else if (base.ai.searchForScrap.visitInProgress)
			{
				base.ai.searchForScrap.StopSearch();
			}
			if (LethalBotManager.AreWeAtTheCompanyBuilding() && base.ai.HasSellableItemInInventory())
			{
				base.ai.State = new SellScrapState(this);
				return;
			}
			SelectBestItemFromInventory();
			Vector3 position = ((Component)((EnemyAI)base.ai).targetPlayer).transform.position;
			Vector3 placePosition = Vector3.Scale(position - ((Component)npcController.Npc).transform.position, new Vector3(1f, 0f, 1f));
			float sqrMagnitude = ((Vector3)(ref placePosition)).sqrMagnitude;
			placePosition = Vector3.Scale(position - ((Component)npcController.Npc).transform.position, new Vector3(0f, 1f, 0f));
			float sqrMagnitude2 = ((Vector3)(ref placePosition)).sqrMagnitude;
			if (sqrMagnitude < 625f && sqrMagnitude2 < 2500f)
			{
				targetLastKnownPosition = position;
				bool flag = false;
				bool flag2 = false;
				if (targetLastKnownPosition.HasValue && (Object)(object)LethalBotAI.ElevatorScript != (Object)null && !base.ai.IsValidPathToTarget(targetLastKnownPosition.Value) && ((EnemyAI)base.ai).targetPlayer.isInsideFactory)
				{
					bool flag3 = base.ai.IsPlayerNearElevatorEntrance(((EnemyAI)base.ai).targetPlayer);
					if (flag3 && !base.ai.IsInElevatorStartRoom)
					{
						flag = base.ai.UseElevator(goUp: true);
						flag2 = true;
						if (flag && !base.ai.AreHandsFree() && base.ai.HeldItem is CaveDwellerPhysicsProp)
						{
							LethalBotAI lethalBotAI = base.ai;
							placePosition = default(Vector3);
							lethalBotAI.DropItem(placeObject: false, null, placePosition);
						}
					}
					else if (!flag3 && base.ai.IsInElevatorStartRoom)
					{
						flag = base.ai.UseElevator(goUp: false);
						flag2 = true;
					}
				}
				if (!flag && !flag2)
				{
					base.ai.SyncAssignTargetAndSetMovingTo(((EnemyAI)base.ai).targetPlayer);
					base.ai.OrderMoveToDestination();
				}
			}
			else
			{
				PlayerControllerB val4 = base.ai.CheckLOSForTarget(90f, 40, 5);
				if ((Object)(object)val4 == (Object)null)
				{
					base.ai.State = new JustLostPlayerState(this);
					return;
				}
				targetLastKnownPosition = position;
				if (targetLastKnownPosition.HasValue && (Object)(object)LethalBotAI.ElevatorScript != (Object)null && !base.ai.IsValidPathToTarget(targetLastKnownPosition.Value))
				{
					bool flag4 = false;
					bool flag5 = false;
					if (((EnemyAI)base.ai).targetPlayer.isInsideFactory)
					{
						bool flag6 = base.ai.IsPlayerNearElevatorEntrance(((EnemyAI)base.ai).targetPlayer);
						if (flag6 && !base.ai.IsInElevatorStartRoom)
						{
							flag4 = base.ai.UseElevator(goUp: true);
							flag5 = true;
							if (flag4 && !base.ai.AreHandsFree() && base.ai.HeldItem is CaveDwellerPhysicsProp)
							{
								LethalBotAI lethalBotAI2 = base.ai;
								placePosition = default(Vector3);
								lethalBotAI2.DropItem(placeObject: false, null, placePosition);
							}
						}
						else if (!flag6 && base.ai.IsInElevatorStartRoom)
						{
							flag4 = base.ai.UseElevator(goUp: false);
							flag5 = true;
						}
					}
					if (!flag4 && !flag5)
					{
						base.ai.SyncAssignTargetAndSetMovingTo(((EnemyAI)base.ai).targetPlayer);
						base.ai.OrderMoveToDestination();
					}
				}
				else
				{
					base.ai.SyncAssignTargetAndSetMovingTo(((EnemyAI)base.ai).targetPlayer);
					base.ai.CheckAndBringCloserTeleportLethalBot(0.8f);
					base.ai.OrderMoveToDestination();
				}
			}
			if (sqrMagnitude < 25f && sqrMagnitude2 < 4f)
			{
				base.ai.State = new ChillWithPlayerState(this);
			}
			else if (sqrMagnitude > 64f || sqrMagnitude2 > 0.09f)
			{
				npcController.OrderToSprint();
			}
			else if (sqrMagnitude < 49f)
			{
				npcController.OrderToStopSprint();
			}
		}

		public override void TryPlayCurrentStateVoiceAudio()
		{
			base.ai.LethalBotIdentity.Voice.TryPlayVoiceAudio(new PlayVoiceParameters
			{
				VoiceState = EnumVoicesState.FollowingPlayer,
				CanTalkIfOtherLethalBotTalk = false,
				WaitForCooldown = true,
				CutCurrentVoiceStateToTalk = false,
				CanRepeatVoiceState = true,
				ShouldSync = true,
				IsLethalBotInside = npcController.Npc.isInsideFactory,
				AllowSwearing = Plugin.Config.AllowSwearing.Value
			});
		}

		public new static void RegisterSignalTranslatorCommands()
		{
			SignalTranslatorCommandsManager.RegisterIgnoreDefaultForState<GetCloseToPlayerState>();
		}
	}
	public class GrabLoadoutState : AIState
	{
		private List<string> itemsToGrab = new List<string>();

		public GrabLoadoutState(AIState oldState, AIState? changeToOnEnd = null)
			: base(oldState, changeToOnEnd)
		{
			base.CurrentState = EnumAIStates.GrabLoadout;
		}

		public GrabLoadoutState(LethalBotAI ai, AIState? changeToOnEnd = null)
			: base(ai, changeToOnEnd)
		{
			base.CurrentState = EnumAIStates.GrabLoadout;
		}

		public override void OnEnterState()
		{
			itemsToGrab.Clear();
			Item[] items = base.ai.LethalBotIdentity.Loadout.Items;
			foreach (Item val in items)
			{
				if ((Object)(object)val != (Object)null && !itemsToGrab.Contains(val.itemName))
				{
					itemsToGrab.Add(val.itemName);
				}
			}
			base.OnEnterState();
		}

		public override void DoAI()
		{
			if (itemsToGrab.Count <= 0)
			{
				ChangeBackToPreviousState();
				return;
			}
			EnemyAI val = base.ai.CheckLOSForEnemy(90f, 40, 5);
			if ((Object)(object)val != (Object)null)
			{
				base.ai.State = new PanikState(this, val);
				return;
			}
			if (!npcController.Npc.isInElevator && !npcController.Npc.isInHangarShipRoom)
			{
				ChangeBackToPreviousState();
				return;
			}
			string name = itemsToGrab[0];
			itemsToGrab.RemoveAt(0);
			GrabbableObject val2 = FindItemWithName(name);
			if ((Object)(object)val2 != (Object)null && base.ai.HasSpaceInInventory(val2))
			{
				base.ai.State = new FetchingObjectState(this, val2);
			}
		}

		public override void TryPlayCurrentStateVoiceAudio()
		{
		}

		private GrabbableObject? FindItemWithName(string name)
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			string name2 = name;
			if (base.ai.HasGrabbableObjectInInventory((Func<GrabbableObject, bool>)((GrabbableObject item) => (Object)(object)item != (Object)null && item.itemProperties.itemName == name2), out int _))
			{
				return null;
			}
			LevelWeatherType levelWeatherType = TimeOfDay.Instance.currentLevelWeather;
			return base.ai.FindItemOnShip((GrabbableObject foundItem) => foundItem.itemProperties.itemName == name2 && ((int)levelWeatherType != 2 || !foundItem.itemProperties.isConductiveMetal));
		}
	}
	public class HealPlayerState : AIState
	{
		public enum HealMethod
		{
			None,
			WeedKiller,
			ModUsualScrapMedkit,
			ModUsualScrapBandage
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass21_0
		{
			public HealPlayerState <>4__this;

			public int itemSlot;

			public float startTime;

			public SprayPaintItem weedKiller;

			internal bool <healUsingWeedKiller>b__0()
			{
				if (<>4__this.npcController.LookAtTarget.IsHeadAimingOnTarget())
				{
					return <>4__this.npcController.LookAtTarget.hasBeenSightedIn;
				}
				return false;
			}

			internal bool <healUsingWeedKiller>b__1()
			{
				if (<>4__this.npcController.Npc.currentItemSlot != itemSlot)
				{
					return Time.timeSinceLevelLoad - startTime > 1f;
				}
				return true;
			}

			internal bool <healUsingWeedKiller>b__2()
			{
				if (!((Object)(object)<>4__this.healTarget == (Object)null) && !<>4__this.healTarget.isPlayerDead && <>4__this.healTarget.isPlayerControlled)
				{
					return !<>4__this.healTarget.criticallyInjured;
				}
				return true;
			}

			internal bool <healUsingWeedKiller>b__3()
			{
				if (!((Object)(object)weedKiller == (Object)null) && isSpraying.Invoke(weedKiller))
				{
					return Time.timeSinceLevelLoad - startTime > 5f;
				}
				return true;
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass23_0
		{
			public HealPlayerState <>4__this;

			public int itemSlot;

			public float startTime;

			public FieldInfo healthpoolField;

			public GrabbableObject heldItem;

			public Func<bool> <>9__2;

			internal bool <healUsingUsualScrapMedkit>b__0()
			{
				if (<>4__this.npcController.LookAtTarget.IsHeadAimingOnTarget())
				{
					return <>4__this.npcController.LookAtTarget.hasBeenSightedIn;
				}
				return false;
			}

			internal bool <healUsingUsualScrapMedkit>b__1()
			{
				if (<>4__this.npcController.Npc.currentItemSlot != itemSlot)
				{
					return Time.timeSinceLevelLoad - startTime > 1f;
				}
				return true;
			}

			internal bool <healUsingUsualScrapMedkit>b__2()
			{
				return (int)healthpoolField.GetValue(heldItem) > 0;
			}
		}

		[CompilerGenerated]
		private sealed class <healUsingUsualScrapMedkit>d__23 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public HealPlayerState <>4__this;

			private <>c__DisplayClass23_0 <>8__1;

			private FieldInfo <healCoroutineRunningField>5__2;

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

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

			[DebuggerHidden]
			public <healUsingUsualScrapMedkit>d__23(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>8__1 = null;
				<healCoroutineRunningField>5__2 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c2: Expected O, but got Unknown
				//IL_0221: Unknown result type (might be due to invalid IL or missing references)
				//IL_022b: Expected O, but got Unknown
				//IL_0408: Unknown result type (might be due to invalid IL or missing references)
				//IL_0412: Expected O, but got Unknown
				//IL_0196: Unknown result type (might be due to invalid IL or missing references)
				//IL_019c: Unknown result type (might be due to invalid IL or missing references)
				int num = <>1__state;
				HealPlayerState healPlayerState = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>8__1 = new <>c__DisplayClass23_0();
					<>8__1.<>4__this = <>4__this;
					if ((Object)(object)healPlayerState.healTarget != (Object)(object)healPlayerState.npcController.Npc)
					{
						healPlayerState.npcController.OrderToLookAtPosition(((NetworkBehaviour)healPlayerState.healTarget).NetworkObject, EnumLookAtPriority.HIGH_PRIORITY, 1f);
						<>2__current = null;
						<>1__state = 1;
						return true;
					}
					goto IL_00d2;
				case 1:
					<>1__state = -1;
					<>2__current = (object)new WaitUntil((Func<bool>)(() => <>8__1.<>4__this.npcController.LookAtTarget.IsHeadAimingOnTarget() && <>8__1.<>4__this.npcController.LookAtTarget.hasBeenSightedIn));
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					goto IL_00d2;
				case 3:
					<>1__state = -1;
					goto IL_01ba;
				case 4:
					<>1__state = -1;
					goto IL_023b;
				case 5:
				{
					<>1__state = -1;
					healPlayerState.npcController.OrderToLookAtPosition(((NetworkBehaviour)healPlayerState.healTarget).NetworkObject, EnumLookAtPriority.HIGH_PRIORITY, 1f);
					if (!(bool)<healCoroutineRunningField>5__2.GetValue(<>8__1.heldItem))
					{
						<>8__1.heldItem.UseItemOnClient(true);
					}
					int num2 = (int)<>8__1.healthpoolField.GetValue(<>8__1.heldItem);
					if (num2 <= 0)
					{
						if (<>8__1.heldItem.itemProperties.holdButtonUse && (bool)<healCoroutineRunningField>5__2.GetValue(<>8__1.heldItem))
						{
							<>8__1.heldItem.UseItemOnClient(false);
						}
						<>2__current = (object)new WaitUntil((Func<bool>)(() => (int)<>8__1.healthpoolField.GetValue(<>8__1.heldItem) > 0));
						<>1__state = 6;
						return true;
					}
					break;
				}
				case 6:
					{
						<>1__state = -1;
						break;
					}
					IL_00d2:
					if (!healPlayerState.ai.HasGrabbableObjectInInventory((Func<GrabbableObject, bool>)FindUsualScrapMedkit, out <>8__1.itemSlot))
					{
						Plugin.LogWarning("[" + healPlayerState.npcController.Npc.playerUsername + "] Tried to heal player " + healPlayerState.healTarget.playerUsername + " using Usual Scrap Medkit but we don't have a Medkit!");
						healPlayerState.StopHealCoroutine();
						return false;
					}
					if (!healPlayerState.ai.AreHandsFree() && !FindUsualScrapMedkit(healPlayerState.ai.HeldItem) && healPlayerState.ai.HeldItem.itemProperties.twoHanded)
					{
						healPlayerState.ai.DropItem();
						<>2__current = null;
						<>1__state = 3;
						return true;
					}
					goto IL_01ba;
					IL_023b:
					<>8__1.heldItem = healPlayerState.ai.HeldItem;
					if (!FindUsualScrapMedkit(<>8__1.heldItem))
					{
						Plugin.LogWarning("[" + healPlayerState.npcController.Npc.playerUsername + "] Tried to heal player " + healPlayerState.healTarget.playerUsername + " using Usual Scrap Medkit but they either don't have a medkit or item switch failed!");
						healPlayerState.StopHealCoroutine();
						return false;
					}
					<>8__1.healthpoolField = AccessTools.Field(typeof(MedicalKitScript), "Healthpool");
					<healCoroutineRunningField>5__2 = AccessTools.Field(typeof(MedicalKitScript), "healCoroutineRunning");
					<>8__1.heldItem.UseItemOnClient(true);
					break;
					IL_01ba:
					<>8__1.startTime = Time.timeSinceLevelLoad;
					if (healPlayerState.npcController.Npc.currentItemSlot != <>8__1.itemSlot || !FindUsualScrapMedkit(healPlayerState.ai.HeldItem))
					{
						healPlayerState.ai.SwitchItemSlotsAndSync(<>8__1.itemSlot);
						<>2__current = (object)new WaitUntil((Func<bool>)(() => <>8__1.<>4__this.npcController.Npc.currentItemSlot == <>8__1.itemSlot || Time.timeSinceLevelLoad - <>8__1.startTime > 1f));
						<>1__state = 4;
						return true;
					}
					goto IL_023b;
				}
				if ((Object)(object)healPlayerState.healTarget != (Object)null && healPlayerState.healTarget.health < 100 && FindUsualScrapMedkit(healPlayerState.ai.HeldItem))
				{
					<>2__current = null;
					<>1__state = 5;
					return true;
				}
				if ((Object)(object)<>8__1.heldItem != (Object)null && (Object)(object)<>8__1.heldItem == (Object)(object)healPlayerState.ai.HeldItem && <>8__1.heldItem.itemProperties.holdButtonUse)
				{
					<>8__1.heldItem.UseItemOnClient(false);
				}
				healPlayerState.StopHealCoroutine();
				return false;
			}

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

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

		[CompilerGenerated]
		private sealed class <healUsingWeedKiller>d__21 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public HealPlayerState <>4__this;

			private <>c__DisplayClass21_0 <>8__1;

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

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

			[DebuggerHidden]
			public <healUsingWeedKiller>d__21(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>8__1 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ae: Expected O, but got Unknown
				//IL_0341: Unknown result type (might be due to invalid IL or missing references)
				//IL_034b: Expected O, but got Unknown
				//IL_0222: Unknown result type (might be due to invalid IL or missing references)
				//IL_022c: Expected O, but got Unknown
				//IL_02dd: Unknown result type (might be due to invalid IL or missing references)
				//IL_02e7: Expected O, but got Unknown
				//IL_018c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0192: Unknown result type (might be due to invalid IL or missing references)
				int num = <>1__state;
				HealPlayerState healPlayerState = <>4__this;
				GrabbableObject heldItem3;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>8__1 = new <>c__DisplayClass21_0();
					<>8__1.<>4__this = <>4__this;
					healPlayerState.npcController.OrderToLookAtPosition(((NetworkBehaviour)healPlayerState.healTarget).NetworkObject, EnumLookAtPriority.HIGH_PRIORITY, 1f, bypassSteadyCheck: false, 40f);
					<>2__current = null;
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<>2__current = (object)new WaitUntil((Func<bool>)(() => <>8__1.<>4__this.npcController.LookAtTarget.IsHeadAimingOnTarget() && <>8__1.<>4__this.npcController.LookAtTarget.hasBeenSightedIn));
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					if (!healPlayerState.ai.HasGrabbableObjectInInventory((Func<GrabbableObject, bool>)FindWeedKiller, out <>8__1.itemSlot))
					{
						Plugin.LogWarning("[" + healPlayerState.npcController.Npc.playerUsername + "] Tried to heal player " + healPlayerState.healTarget.playerUsername + " using Weed Killer but we don't have a Weed Killer!");
						healPlayerState.StopHealCoroutine();
						return false;
					}
					if (!healPlayerState.ai.AreHandsFree())
					{
						GrabbableObject? heldItem2 = healPlayerState.ai.HeldItem;
						SprayPaintItem val2 = (SprayPaintItem)(object)((heldItem2 is SprayPaintItem) ? heldItem2 : null);
						if ((val2 == null || !val2.isWeedKillerSprayBottle) && healPlayerState.ai.HeldItem.itemProperties.twoHanded)
						{
							healPlayerState.ai.DropItem();
							<>2__current = null;
							<>1__state = 3;
							return true;
						}
					}
					goto IL_01b1;
				case 3:
					<>1__state = -1;
					goto IL_01b1;
				case 4:
					<>1__state = -1;
					goto IL_023c;
				case 5:
					<>1__state = -1;
					<>8__1.startTime = Time.timeSinceLevelLoad;
					((GrabbableObject)<>8__1.weedKiller).UseItemOnClient(true);
					<>2__current = null;
					<>1__state = 6;
					return true;
				case 6:
					<>1__state = -1;
					<>2__current = (object)new WaitUntil((Func<bool>)(() => (Object)(object)<>8__1.weedKiller == (Object)null || !isSpraying.Invoke(<>8__1.weedKiller) || Time.timeSinceLevelLoad - <>8__1.startTime > 5f));
					<>1__state = 7;
					return true;
				case 7:
					{
						<>1__state = -1;
						if ((Object)(object)<>8__1.weedKiller != (Object)null && ((GrabbableObject)<>8__1.weedKiller).itemProperties.holdButtonUse)
						{
							((GrabbableObject)<>8__1.weedKiller).UseItemOnClient(false);
						}
						healPlayerState.StopHealCoroutine();
						return false;
					}
					IL_01b1:
					<>8__1.startTime = Time.timeSinceLevelLoad;
					if (healPlayerState.npcController.Npc.currentItemSlot == <>8__1.itemSlot)
					{
						GrabbableObject? heldItem = healPlayerState.ai.HeldItem;
						SprayPaintItem val = (SprayPaintItem)(object)((heldItem is SprayPaintItem) ? heldItem : null);
						if (val != null && val.isWeedKillerSprayBottle)
						{
							goto IL_023c;
						}
					}
					healPlayerState.ai.SwitchItemSlotsAndSync(<>8__1.itemSlot);
					<>2__current = (object)new WaitUntil((Func<bool>)(() => <>8__1.<>4__this.npcController.Npc.currentItemSlot == <>8__1.itemSlot || Time.timeSinceLevelLoad - <>8__1.startTime > 1f));
					<>1__state = 4;
					return true;
					IL_023c:
					heldItem3 = healPlayerState.ai.HeldItem;
					<>8__1.weedKiller = (SprayPaintItem)(object)((heldItem3 is SprayPaintItem) ? heldItem3 : null);
					if (<>8__1.weedKiller == null || !<>8__1.weedKiller.isWeedKillerSprayBottle)
					{
						Plugin.LogWarning("[" + healPlayerState.npcController.Npc.playerUsername + "] Tried to heal player " + healPlayerState.healTarget.playerUsername + " using Weed Killer but they either don't have weed killer or item switch failed!");
						healPlayerState.StopHealCoroutine();
						return false;
					}
					<>2__current = (object)new WaitUntil((Func<bool>)(() => (Object)(object)<>8__1.<>4__this.healTarget == (Object)null || <>8__1.<>4__this.healTarget.isPlayerDead || !<>8__1.<>4__this.healTarget.isPlayerControlled || !<>8__1.<>4__this.healTarget.criticallyInjured));
					<>1__state = 5;
					return true;
				}
			}

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

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

		private static readonly FieldRef<SprayPaintItem, float> sprayCanTank = (FieldRef<SprayPaintItem, float>)(object)AccessTools.FieldRefAccess<float>(typeof(SprayPaintItem), "sprayCanTank");

		private static readonly FieldRef<SprayPaintItem, bool> isSpraying = (FieldRef<SprayPaintItem, bool>)(object)AccessTools.FieldRefAccess<bool>(typeof(SprayPaintItem), "isSpraying");

		private PlayerControllerB healTarget;

		private GrabbableObject? neededMedicalTool;

		private bool allowRecharging;

		private HealMethod healMethod;

		private Coroutine? healCoroutine;

		public HealPlayerState(AIState oldState, PlayerControllerB targetPlayer)
			: base(oldState)
		{
			base.CurrentState = EnumAIStates.HealPlayer;
			healTarget = targetPlayer;
		}

		public HealPlayerState(LethalBotAI ai, PlayerControllerB targetPlayer)
			: base(ai)
		{
			base.CurrentState = EnumAIStates.HealPlayer;
			healTarget = targetPlayer;
		}

		public override void OnEnterState()
		{
			if ((Object)(object)healTarget == (Object)null || !healTarget.isPlayerControlled || healTarget.isPlayerDead)
			{
				Plugin.LogWarning("HealPlayerState: healTarget is null or dead, cannot heal!");
				ChangeBackToPreviousState();
				return;
			}
			if (!hasBeenStarted)
			{
				healMethod = DetermineBestHealMethod();
			}
			allowRecharging = true;
			base.OnEnterState();
		}

		public override void OnExitState(AIState newState)
		{
			GrabbableObject heldItem = base.ai.HeldItem;
			SprayPaintItem val = (SprayPaintItem)(object)((heldItem is SprayPaintItem) ? heldItem : null);
			if (val != null && isSpraying.Invoke(val))
			{
				((GrabbableObject)val).UseItemOnClient(false);
			}
			else if (Plugin.IsModUsualScrapLoaded && FindUsualScrapMedkit(heldItem))
			{
				heldItem.UseItemOnClient(false);
			}
			base.OnExitState(newState);
		}

		public override void DoAI()
		{
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			EnemyAI val = base.ai.CheckLOSForEnemy(90f, 40, 5);
			if ((Object)(object)val != (Object)null)
			{
				base.ai.State = new PanikState(this, val);
				return;
			}
			if ((Object)(object)healTarget == (Object)null || !healTarget.isPlayerControlled || healTarget.isPlayerDead || !base.ai.IsValidPathToTarget(((Component)healTarget).transform.position))
			{
				ChangeBackToPreviousState();
				return;
			}
			if (!CanHealPlayer())
			{
				ChangeBackToPreviousState();
				return;
			}
			GrabbableObject val2 = neededMedicalTool;
			if ((Object)(object)val2 != (Object)null)
			{
				neededMedicalTool = null;
				base.ai.State = new FetchingObjectState(this, val2);
				return;
			}
			if (allowRecharging && (npcController.Npc.isInElevator || npcController.Npc.isInHangarShipRoom) && ChargeHeldItemState.HasItemToCharge(base.ai, out GrabbableObject _))
			{
				base.ai.State = new ChargeHeldItemState(this, chargeAllHeldItems: true);
				return;
			}
			switch (healMethod)
			{
			case HealMethod.WeedKiller:
				DoWeedKillerHealingLogic();
				break;
			case HealMethod.ModUsualScrapMedkit:
				DoUsualScrapMedkitLogic();
				break;
			case HealMethod.ModUsualScrapBandage:
				DoUsualScrapBandageLogic();
				break;
			}
		}

		public override void TryPlayCurrentStateVoiceAudio()
		{
		}

		public override void StopAllCoroutines()
		{
			base.StopAllCoroutines();
			StopHealCoroutine();
		}

		private HealMethod DetermineBestHealMethod()
		{
			if (CanHealPlayerWithWeedKiller(base.ai, healTarget))
			{
				return HealMethod.WeedKiller;
			}
			if (Plugin.IsModUsualScrapLoaded && CanHealPlayerWithUsualScrapMedkit(base.ai, healTarget))
			{
				return HealMethod.ModUsualScrapMedkit;
			}
			if (Plugin.IsModUsualScrapLoaded && CanHealPlayerWithUsualScrapBandage(base.ai, healTarget))
			{
				return HealMethod.ModUsualScrapBandage;
			}
			return HealMethod.None;
		}

		private static bool CanHealPlayerWithWeedKiller(LethalBotAI lethalBotAI, PlayerControllerB healTarget, float requiredInfectionLevel = 0f)
		{
			PlayerControllerB val = lethalBotAI?.NpcController?.Npc;
			if ((Object)(object)val == (Object)(object)healTarget)
			{
				return false;
			}
			if ((Object)(object)CadaverGrowthAIPatch.CadaverGrowthAI == (Object)null)
			{
				return false;
			}
			PlayerInfection val2 = CadaverGrowthAIPatch.CadaverGrowthAI.playerInfections[healTarget.playerClientId];
			if (!val2.infected || val2.infectionMeter < requiredInfectionLevel)
			{
				return false;
			}
			if ((Object)(object)lethalBotAI != (Object)null && !lethalBotAI.HasGrabbableObjectInInventory((Func<GrabbableObject, bool>)FindWeedKiller, out int _))
			{
				if (!((Object)(object)val != (Object)null) || val.isInElevator || val.isInHangarShipRoom)
				{
					GrabbableObject val3 = lethalBotAI.FindItemOnShip(FindWeedKiller);
					if (val3 != null && lethalBotAI.HasSpaceInInventory(val3))
					{
						goto IL_00d0;
					}
				}
				return false;
			}
			goto IL_00d0;
			IL_00d0:
			return true;
		}

		private static bool CanHealPlayerWithUsualScrapMedkit(LethalBotAI lethalBotAI, PlayerControllerB healTarget)
		{
			if (Plugin.IsModUsualScrapLoaded)
			{
				PlayerControllerB val = lethalBotAI?.NpcController?.Npc;
				if (healTarget.health >= 100)
				{
					return false;
				}
				if ((Object)(object)lethalBotAI != (Object)null && !lethalBotAI.HasGrabbableObjectInInventory((Func<GrabbableObject, bool>)FindUsualScrapMedkit, out int _))
				{
					if (!((Object)(object)val != (Object)null) || val.isInElevator || val.isInHangarShipRoom)
					{
						GrabbableObject val2 = lethalBotAI.FindItemOnShip(FindUsualScrapMedkit);
						if (val2 != null && lethalBotAI.HasSpaceInInventory(val2))
						{
							goto IL_00a6;
						}
					}
					return false;
				}
				goto IL_00a6;
			}
			return false;
			IL_00a6:
			return true;
		}

		private static bool CanHealPlayerWithUsualScrapBandage(LethalBotAI lethalBotAI, PlayerControllerB healTarget)
		{
			if (Plugin.IsModUsualScrapLoaded)
			{
				PlayerControllerB val = lethalBotAI.NpcController?.Npc;
				if ((Object)(object)val != (Object)(object)healTarget || (float)healTarget.health >= Mathf.Min(100f, (float)(lethalBotAI.LethalBotIdentity.HpMax - 20)))
				{
					return false;
				}
				if ((Object)(object)lethalBotAI != (Object)null && !lethalBotAI.HasGrabbableObjectInInventory((Func<GrabbableObject, bool>)FindUsualScrapBandage, out int _))
				{
					if (!((Object)(object)val != (Object)null) || val.isInElevator || val.isInHangarShipRoom)
					{
						GrabbableObject val2 = lethalBotAI.FindItemOnShip(FindUsualScrapBandage);
						if (val2 != null && lethalBotAI.HasSpaceInInventory(val2))
						{
							goto IL_00c1;
						}
					}
					return false;
				}
				goto IL_00c1;
			}
			return false;
			IL_00c1:
			return true;
		}

		private bool CanHealPlayer()
		{
			return healMethod switch
			{
				HealMethod.WeedKiller => CanHealPlayerWithWeedKiller(base.ai, healTarget), 
				HealMethod.ModUsualScrapMedkit => CanHealPlayerWithUsualScrapMedkit(base.ai, healTarget), 
				HealMethod.ModUsualScrapBandage => CanHealPlayerWithUsualScrapBandage(base.ai, healTarget), 
				_ => false, 
			};
		}

		public static bool CanHealPlayer(LethalBotAI lethalBotAI, PlayerControllerB healTarget, float requiredInfectionLevel = 0f)
		{
			if ((Object)(object)healTarget == (Object)null || !healTarget.isPlayerControlled || healTarget.isPlayerDead)
			{
				return false;
			}
			if (CanHealPlayerWithWeedKiller(lethalBotAI, healTarget, requiredInfectionLevel))
			{
				return true;
			}
			if (Plugin.IsModUsualScrapLoaded && CanHealPlayerWithUsualScrapMedkit(lethalBotAI, healTarget))
			{
				return true;
			}
			if (Plugin.IsModUsualScrapLoaded && CanHealPlayerWithUsualScrapBandage(lethalBotAI, healTarget))
			{
				return true;
			}
			return false;
		}

		[IteratorStateMachine(typeof(<healUsingWeedKiller>d__21))]
		private IEnumerator healUsingWeedKiller()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <healUsingWeedKiller>d__21(0)
			{
				<>4__this = this
			};
		}

		private void DoWeedKillerHealingLogic()
		{
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			if (!base.ai.HasGrabbableObjectInInventory((Func<GrabbableObject, bool>)FindWeedKiller, out int _))
			{
				neededMedicalTool = base.ai.FindItemOnShip(FindWeedKiller);
				if ((Object)(object)neededMedicalTool == (Object)null || !base.ai.HasSpaceInInventory(neededMedicalTool))
				{
					ChangeBackToPreviousState();
				}
				return;
			}
			Vector3 val = ((Component)healTarget).transform.position - ((Component)npcController.Npc).transform.position;
			float sqrMagnitude = ((Vector3)(ref val)).sqrMagnitude;
			RaycastHit val2 = default(RaycastHit);
			if (sqrMagnitude > 9f || (Physics.Linecast(((Component)npcController.Npc.gameplayCamera).transform.position, ((Component)healTarget.gameplayCamera).transform.position, ref val2, StartOfRound.Instance.collidersAndRoomMaskAndDefault) && (Object)(object)((Component)((RaycastHit)(ref val2)).transform).GetComponent<PlayerControllerB>() != (Object)(object)healTarget))
			{
				SelectBestItemFromInventory();
				base.ai.SetDestinationToPositionLethalBotAI(((Component)healTarget).transform.position);
				if (!npcController.WaitForFullStamina && sqrMagnitude > 4f)
				{
					npcController.OrderToSprint();
				}
				else
				{
					npcController.OrderToStopSprint();
				}
				base.ai.OrderMoveToDestination();
			}
			else
			{
				base.ai.StopMoving();
				npcController.OrderToStopSprint();
				if (healCoroutine == null)
				{
					healCoroutine = ((MonoBehaviour)base.ai).StartCoroutine(healUsingWeedKiller());
				}
			}
		}

		[IteratorStateMachine(typeof(<healUsingUsualScrapMedkit>d__23))]
		private IEnumerator healUsingUsualScrapMedkit()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <healUsingUsualScrapMedkit>d__23(0)
			{
				<>4__this = this
			};
		}

		private void DoUsualScrapMedkitLogic()
		{
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			if (!base.ai.HasGrabbableObjectInInventory((Func<GrabbableObject, bool>)FindUsualScrapMedkit, out int _))
			{
				neededMedicalTool = base.ai.FindItemOnShip(FindUsualScrapMedkit);
				if ((Object)(object)neededMedicalTool == (Object)null || !base.ai.HasSpaceInInventory(neededMedicalTool))
				{
					ChangeBackToPreviousState();
				}
				return;
			}
			Vector3 val = ((Component)healTarget).transform.position - ((Component)npcController.Npc).transform.position;
			float sqrMagnitude = ((Vector3)(ref val)).sqrMagnitude;
			RaycastHit val2 = default(RaycastHit);
			if (sqrMagnitude > 9f || (Physics.Linecast(((Component)npcController.Npc.gameplayCamera).transform.position, ((Component)healTarget.gameplayCamera).transform.position, ref val2, StartOfRound.Instance.collidersAndRoomMaskAndDefault) && (Object)(object)((Component)((RaycastHit)(ref val2)).transform).GetComponent<PlayerControllerB>() != (Object)(object)healTarget))
			{
				SelectBestItemFromInventory();
				base.ai.SetDestinationToPositionLethalBotAI(((Component)healTarget).transform.position);
				if (!npcController.WaitForFullStamina && sqrMagnitude > 4f)
				{
					npcController.OrderToSprint();
				}
				else
				{
					npcController.OrderToStopSprint();
				}
				base.ai.OrderMoveToDestination();
			}
			else
			{
				base.ai.StopMoving();
				npcController.OrderToStopSprint();
				if (healCoroutine == null)
				{
					healCoroutine = ((MonoBehaviour)base.ai).StartCoroutine(healUsingUsualScrapMedkit());
				}
			}
		}

		private void DoUsualScrapBandageLogic()
		{
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			if (!base.ai.HasGrabbableObjectInInventory((Func<GrabbableObject, bool>)FindUsualScrapBandage, out int objectSlot))
			{
				neededMedicalTool = base.ai.FindItemOnShip(FindUsualScrapBandage);
				if ((Object)(object)neededMedicalTool == (Object)null || !base.ai.HasSpaceInInventory(neededMedicalTool))
				{
					ChangeBackToPreviousState();
				}
			}
			else if (!FindUsualScrapBandage(base.ai.HeldItem) || npcController.Npc.currentItemSlot != objectSlot)
			{
				if ((Object)(object)base.ai.HeldItem != (Object)null && base.ai.HeldItem.itemProperties.twoHanded)
				{
					base.ai.DropItem();
				}
				else
				{
					base.ai.SwitchItemSlotsAndSync(objectSlot);
				}
			}
			else
			{
				base.ai.HeldItem.UseItemOnClient(true);
			}
		}

		private static bool FindWeedKiller(GrabbableObject item)
		{
			SprayPaintItem val = (SprayPaintItem)(object)((item is SprayPaintItem) ? item : null);
			if (val != null && val.isWeedKillerSprayBottle)
			{
				return sprayCanTank.Invoke(val) > 0f;
			}
			return false;
		}

		private static bool FindUsualScrapMedkit([NotNullWhen(true)] GrabbableObject? item)
		{
			return item is MedicalKitScript;
		}

		private static bool FindUsualScrapBandage([NotNullWhen(true)] GrabbableObject? item)
		{
			return item is BandagesScript;
		}

		private void StopHealCoroutine()
		{
			if (healCoroutine != null)
			{
				((MonoBehaviour)base.ai).StopCoroutine(healCoroutine);
				healCoroutine = null;
			}
		}
	}
	public class JustLostPlayerState : AIState
	{
		[CompilerGenerated]
		private sealed class <LookingAround>d__9 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public JustLostPlayerState <>4__this;

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

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

			[DebuggerHidden]
			public <LookingAround>d__9(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0074: 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_0093: Unknown result type (might be due to invalid IL or missing references)
				//IL_009f: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a9: Expected O, but got Unknown
				int num = <>1__state;
				JustLostPlayerState justLostPlayerState = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = null;
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					break;
				case 2:
					<>1__state = -1;
					break;
				}
				if (justLostPlayerState.lookingAroundTimer < 6f)
				{
					float num2 = Random.Range(0.5f, 2f);
					float num3 = Random.Range(-180, 180);
					justLostPlayerState.npcController.SetTurnBodyTowardsDirection(Quaternion.Euler(0f, num3, 0f) * ((Component)justLostPlayerState.npcController.Npc.thisController).transform.forward);
					<>2__current = (object)new WaitForSeconds(num2);
					<>1__state = 2;
					return true;
				}
				return false;
			}

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

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

		private float lookingAroundTimer;

		public JustLostPlayerState(AIState state)
			: base(state)
		{
			base.CurrentState = EnumAIStates.JustLostPlayer;
		}

		public override void DoAI()
		{
			//IL_01f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0206: Unknown result type (might be due to invalid IL or missing references)
			//IL_0225: Unknown result type (might be due to invalid IL or missing references)
			//IL_023a: Unknown result type (might be due to invalid IL or missing references)
			//IL_023f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0244: Unknown result type (might be due to invalid IL or missing references)
			//IL_0407: Unknown result type (might be due to invalid IL or missing references)
			//IL_049c: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_0282: Unknown result type (might be due to invalid IL or missing references)
			//IL_0288: Unknown result type (might be due to invalid IL or missing references)
			//IL_045f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0465: Unknown result type (might be due to invalid IL or missing references)
			//IL_04f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_051d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0573: Unknown result type (might be due to invalid IL or missing references)
			//IL_0588: Unknown result type (might be due to invalid IL or missing references)
			//IL_05d3: Unknown result type (might be due to invalid IL or missing references)
			EnemyAI val = base.ai.CheckLOSForEnemy(90f, 40, 5);
			if ((Object)(object)val != (Object)null)
			{
				base.ai.State = new PanikState(this, val);
				return;
			}
			if (lookingAroundTimer > 6f)
			{
				lookingAroundTimer = 0f;
				targetLastKnownPosition = null;
				StopLookingAroundCoroutine();
			}
			if (lookingAroundTimer > 0f)
			{
				lookingAroundTimer += ((EnemyAI)base.ai).AIIntervalTime;
				Plugin.LogDebug($"{base.ai.NpcController.Npc.playerUsername} Looking around to find player {lookingAroundTimer}");
				base.ai.StopMoving();
				StartLookingAroundCoroutine();
				CheckLOSForTargetAndGetClose();
				return;
			}
			PlayerControllerB val2 = base.ai.LookingForPlayerToRevive();
			if ((Object)(object)val2 != (Object)null)
			{
				base.ai.State = new RescueAndReviveState(this, val2);
				return;
			}
			val2 = base.ai.LookingForPlayerToHeal();
			if ((Object)(object)val2 != (Object)null)
			{
				base.ai.State = new HealPlayerState(this, val2);
				return;
			}
			if (base.ai.HasSpaceInInventory())
			{
				GrabbableObject val3 = base.ai.LookingForObjectToGrab();
				if ((Object)(object)val3 != (Object)null)
				{
					base.ai.State = new FetchingObjectState(this, val3);
					return;
				}
				if (!base.ai.searchForScrap.visitInProgress && !((EnemyAI)base.ai).isOutside)
				{
					base.ai.searchForScrap.StartVisit();
				}
			}
			else if (base.ai.searchForScrap.visitInProgress)
			{
				base.ai.searchForScrap.StopSearch();
			}
			if (!targetLastKnownPosition.HasValue)
			{
				base.ai.State = new SearchingForPlayerState(this);
				return;
			}
			Plugin.LogDebug($"{npcController.Npc.playerUsername} distance to last position {Vector3.Distance(targetLastKnownPosition.Value, ((Component)npcController.Npc).transform.position)}");
			Vector3 placePosition = targetLastKnownPosition.Value - ((Component)npcController.Npc).transform.position;
			float sqrMagnitude = ((Vector3)(ref placePosition)).sqrMagnitude;
			if (sqrMagnitude < 1f)
			{
				if (!base.ai.AreHandsFree() && base.ai.HeldItem is CaveDwellerPhysicsProp)
				{
					LethalBotAI lethalBotAI2 = base.ai;
					placePosition = default(Vector3);
					lethalBotAI2.DropItem(placeObject: false, null, placePosition);
					return;
				}
				if (Time.timeSinceLevelLoad - base.ai.TimeSinceTeleporting > 1f)
				{
					EntranceTeleport entrance = base.ai.IsEntranceCloseForBoth(targetLastKnownPosition.Value, ((Component)npcController.Npc).transform.position);
					Vector3? entranceTeleportPos = base.ai.GetTeleportPosOfEntrance(entrance);
					if (entranceTeleportPos.HasValue)
					{
						base.ai.StopMoving();
						if (base.LethalBotInteraction == null || base.LethalBotInteraction.IsCompleted)
						{
							base.LethalBotInteraction = new LethalBotInteraction(PatchesUtil.triggerScriptField.Invoke(entrance), delegate(LethalBotAI lethalBotAI, PlayerControllerB lethalBotController, InteractTrigger _)
							{
								//IL_002b: Unknown result type (might be due to invalid IL or missing references)
								//IL_0076: Unknown result type (might be due to invalid IL or missing references)
								Plugin.LogDebug("======== TeleportLethalBotAndSync " + lethalBotController.playerUsername + " !!!!!!!!!!!!!!! ");
								LethalBotAI lethalBotAI4 = base.ai;
								Vector3 value = entranceTeleportPos.Value;
								EntranceTeleport obj = entrance;
								lethalBotAI4.SyncTeleportLethalBot(value, (obj != null) ? (!obj.isEntranceToBuilding) : (!((EnemyAI)lethalBotAI).isOutside), entrance);
								targetLastKnownPosition = ((Component)((EnemyAI)lethalBotAI).targetPlayer).transform.position;
								lethalBotAI.State = new GetCloseToPlayerState(this);
							}, ignoreInteractablility: false, skipOriginalInteract: true);
						}
						return;
					}
					if (lookingAroundTimer <= 0f)
					{
						lookingAroundTimer = ((EnemyAI)base.ai).AIIntervalTime;
					}
					base.ai.LethalBotIdentity.Voice.TryPlayVoiceAudio(new PlayVoiceParameters
					{
						VoiceState = EnumVoicesState.LosingPlayer,
						CanTalkIfOtherLethalBotTalk = true,
						WaitForCooldown = false,
						CutCurrentVoiceStateToTalk = true,
						CanRepeatVoiceState = false,
						ShouldSync = true,
						IsLethalBotInside = npcController.Npc.isInsideFactory,
						AllowSwearing = Plugin.Config.AllowSwearing.Value
					});
					return;
				}
			}
			CheckLOSForTargetOrClosestPlayer();
			SelectBestItemFromInventory();
			bool flag = false;
			bool flag2 = base.ai.IsPositionNearElevatorEntrance(targetLastKnownPosition.Value);
			if (flag2 && !base.ai.IsInElevatorStartRoom)
			{
				flag = base.ai.UseElevator(goUp: true);
				if (flag && !base.ai.AreHandsFree() && base.ai.HeldItem is CaveDwellerPhysicsProp)
				{
					LethalBotAI lethalBotAI3 = base.ai;
					placePosition = default(Vector3);
					lethalBotAI3.DropItem(placeObject: false, null, placePosition);
				}
			}
			else if (!flag2 && base.ai.IsInElevatorStartRoom)
			{
				flag = base.ai.UseElevator(goUp: false);
			}
			else
			{
				base.ai.SetDestinationToPositionLethalBotAI(targetLastKnownPosition.Value);
				base.ai.OrderMoveToDestination();
			}
			if (sqrMagnitude < 4f)
			{
				npcController.OrderToStopSprint();
			}
			else
			{
				npcController.OrderToSprint();
			}
			bool flag3 = !flag && !base.ai.IsInsideElevator;
			targetLastKnownPosition = ((!flag3) ? targetLastKnownPosition : new Vector3?(((EnemyAI)base.ai).destination));
			if (!flag3 || base.ai.IsValidPathToTarget(targetLastKnownPosition.Value))
			{
				return;
			}
			Vector3? val4 = null;
			bool isInsideFactory = ((EnemyAI)base.ai).targetPlayer.isInsideFactory;
			bool flag4 = !((EnemyAI)base.ai).isOutside;
			if (isInsideFactory != flag4)
			{
				EntranceTeleport val5 = base.ai.IsEntranceCloseForBoth(targetLastKnownPosition.Value, ((Component)((EnemyAI)base.ai).targetPlayer).transform.position) ?? FindClosestEntrance();
				if ((Object)(object)val5 != (Object)null && (Object)(object)val5 != (Object)(object)targetEntrance)
				{
					targetEntrance = val5;
					val4 = val5.entrancePoint.position;
				}
			}
			targetLastKnownPosition = val4;
		}

		public override void TryPlayCurrentStateVoiceAudio()
		{
			base.ai.LethalBotIdentity.Voice.TryPlayVoiceAudio(new PlayVoiceParameters
			{
				VoiceState = EnumVoicesState.LosingPlayer,
				CanTalkIfOtherLethalBotTalk = true,
				WaitForCooldown = true,
				CutCurrentVoiceStateToTalk = false,
				CanRepeatVoiceState = false,
				ShouldSync = true,
				IsLethalBotInside = npcController.Npc.isInsideFactory,
				AllowSwearing = Plugin.Config.AllowSwearing.Value
			});
		}

		public override void PlayerHeard(Vector3 noisePosition)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			lookingAroundTimer = 0f;
			targetLastKnownPosition = noisePosition;
			base.ai.LethalBotIdentity.Voice.TryPlayVoiceAudio(new PlayVoiceParameters
			{
				VoiceState = EnumVoicesState.HearsPlayer,
				CanTalkIfOtherLethalBotTalk = true,
				WaitForCooldown = false,
				CutCurrentVoiceStateToTalk = true,
				CanRepeatVoiceState = true,
				ShouldSync = true,
				IsLethalBotInside = npcController.Npc.isInsideFactory,
				AllowSwearing = Plugin.Config.AllowSwearing.Value
			});
		}

		public new static void RegisterSignalTranslatorCommands()
		{
			SignalTranslatorCommandsManager.RegisterIgnoreDefaultForState<JustLostPlayerState>();
		}

		public override string GetBillboardStateIndicator()
		{
			return "!?";
		}

		private void CheckLOSForTargetAndGetClose()
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			PlayerControllerB val = base.ai.CheckLOSForTarget(90f, 40, 5);
			if ((Object)(object)val != (Object)null)
			{
				StopLookingAroundCoroutine();
				targetLastKnownPosition = ((Component)val).transform.position;
				if (lookingAroundTimer > 0f)
				{
					base.ai.LethalBotIdentity.Voice.TryPlayVoiceAudio(new PlayVoiceParameters
					{
						VoiceState = EnumVoicesState.LostAndFound,
						CanTalkIfOtherLethalBotTalk = false,
						WaitForCooldown = false,
						CutCurrentVoiceStateToTalk = true,
						ShouldSync = true,
						IsLethalBotInside = npcController.Npc.isInsideFactory,
						AllowSwearing = Plugin.Config.AllowSwearing.Value
					});
				}
				base.ai.State = new GetCloseToPlayerState(this);
			}
		}

		private void CheckLOSForTargetOrClosestPlayer()
		{
			if ((Object)(object)((EnemyAI)base.ai).targetPlayer == (Object)null)
			{
				PlayerControllerB val = base.ai.CheckLOSForClosestPlayer(90f, 40, 5);
				if ((Object)(object)val != (Object)null)
				{
					base.ai.SyncAssignTargetAndSetMovingTo(val);
					if (Plugin.Config.ChangeSuitAutoBehaviour.Value)
					{
						base.ai.ChangeSuitLethalBotServerRpc(npcController.Npc.playerClientId, val.currentSuitID);
					}
				}
			}
			else
			{
				CheckLOSForTargetAndGetClose();
			}
		}

		[IteratorStateMachine(typeof(<LookingAround>d__9))]
		protected override IEnumerator LookingAround()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <LookingAround>d__9(0)
			{
				<>4__this = this
			};
		}
	}
	public class LostInFacilityState : AIState
	{
		[CompilerGenerated]
		private sealed class <SearchingWander>d__9 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public LostInFacilityState <>4__this;

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

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

			[DebuggerHidden]
			public <SearchingWander>d__9(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_009a: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a4: Expected O, but got Unknown
				//IL_0063: Unknown result type (might be due to invalid IL or missing references)
				//IL_006d: Expected O, but got Unknown
				int num = <>1__state;
				LostInFacilityState lostInFacilityState = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = null;
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					break;
				case 2:
				{
					<>1__state = -1;
					float num2 = Random.Range(1f, 3f);
					lostInFacilityState.npcController.OrderToStopSprint();
					<>2__current = (object)new WaitForSeconds(num2);
					<>1__state = 3;
					return true;
				}
				case 3:
					<>1__state = -1;
					break;
				}
				if (lostInFacilityState.ai.State != null && lostInFacilityState.ai.State == lostInFacilityState)
				{
					float num2 = Random.Range(1f, 3f);
					lostInFacilityState.npcController.OrderToSprint();
					<>2__current = (object)new WaitForSeconds(num2);
					<>1__state = 2;
					return true;
				}
				return false;
			}

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

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

		private Coroutine searchingWanderCoroutine;

		private float findEntranceTimer;

		private LethalBotSearchRoutine searchForExit;

		public LostInFacilityState(AIState oldState)
			: base(oldState)
		{
			base.CurrentState = EnumAIStates.LostInFacility;
			searchForExit = new LethalBotSearchRoutine(base.ai);
		}

		public LostInFacilityState(LethalBotAI ai)
			: base(ai)
		{
			base.CurrentState = EnumAIStates.LostInFacility;
			searchForExit = new LethalBotSearchRoutine(ai);
		}

		public override void DoAI()
		{
			//IL_0240: Unknown result type (might be due to invalid IL or missing references)
			StartSearchingWanderCoroutine();
			EnemyAI val = base.ai.CheckLOSForEnemy(90f, 40, 5);
			if ((Object)(object)val != (Object)null)
			{
				base.ai.State = new PanikState(this, val);
				return;
			}
			PlayerControllerB val2 = base.ai.LookingForPlayerToRevive();
			if ((Object)(object)val2 != (Object)null)
			{
				base.ai.State = new RescueAndReviveState(this, val2);
				return;
			}
			val2 = base.ai.LookingForPlayerToHeal();
			if ((Object)(object)val2 != (Object)null)
			{
				base.ai.State = new HealPlayerState(this, val2);
				return;
			}
			Vector3? targetPosition;
			if (base.ai.HasSpaceInInventory())
			{
				GrabbableObject val3 = base.ai.LookingForObjectToGrab();
				if ((Object)(object)val3 != (Object)null)
				{
					base.ai.State = new FetchingObjectState(this, val3);
					return;
				}
				targetPosition = base.ai.searchForScrap.GetTargetPosition();
				if (searchForExit.searchInProgress)
				{
					searchForExit.StopSearch();
				}
				if (!base.ai.searchForScrap.searchInProgress)
				{
					base.ai.searchForScrap.StartSearch();
				}
			}
			else
			{
				targetPosition = searchForExit.GetTargetPosition();
				if (base.ai.searchForScrap.searchInProgress)
				{
					base.ai.searchForScrap.StopSearch();
				}
				if (!searchForExit.searchInProgress)
				{
					searchForExit.StartSearch();
				}
			}
			if (((EnemyAI)base.ai).isOutside)
			{
				Plugin.LogError("Bot " + npcController.Npc.playerUsername + " is outside but in LostInFacilityState. This should not happen!");
				ChangeBackToPreviousState();
				return;
			}
			if (findEntranceTimer > 2f)
			{
				findEntranceTimer = 0f;
				EntranceTeleport val4 = FindClosestEntrance();
				if ((Object)(object)val4 != (Object)null)
				{
					ChangeBackToPreviousState();
					return;
				}
			}
			else
			{
				findEntranceTimer += ((EnemyAI)base.ai).AIIntervalTime;
			}
			DoorLock val5 = base.ai.UnlockDoorIfNeeded(200f);
			if ((Object)(object)val5 != (Object)null)
			{
				findEntranceTimer = float.MaxValue;
				base.ai.State = new UseKeyOnLockedDoorState(this, val5);
				return;
			}
			SelectBestItemFromInventory();
			if (targetPosition.HasValue)
			{
				base.ai.SetDestinationToPositionLethalBotAI(targetPosition.Value);
				base.ai.OrderMoveToDestination();
			}
		}

		public override void StopAllCoroutines()
		{
			base.StopAllCoroutines();
			searchForExit.StopSearch();
			StopSearchingWanderCoroutine();
		}

		protected override bool ShouldOnlyUseFrontEntrance()
		{
			return false;
		}

		public override void TryPlayCurrentStateVoiceAudio()
		{
			base.ai.LethalBotIdentity.Voice.TryPlayVoiceAudio(new PlayVoiceParameters
			{
				VoiceState = EnumVoicesState.Lost,
				CanTalkIfOtherLethalBotTalk = true,
				WaitForCooldown = true,
				CutCurrentVoiceStateToTalk = false,
				CanRepeatVoiceState = true,
				ShouldSync = true,
				IsLethalBotInside = npcController.Npc.isInsideFactory,
				AllowSwearing = Plugin.Config.AllowSwearing.Value
			});
		}

		[IteratorStateMachine(typeof(<SearchingWander>d__9))]
		private IEnumerator SearchingWander()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <SearchingWander>d__9(0)
			{
				<>4__this = this
			};
		}

		private void StartSearchingWanderCoroutine()
		{
			if (searchingWanderCoroutine == null)
			{
				searchingWanderCoroutine = ((MonoBehaviour)base.ai).StartCoroutine(SearchingWander());
			}
		}

		private void StopSearchingWanderCoroutine()
		{
			if (searchingWanderCoroutine != null)
			{
				((MonoBehaviour)base.ai).StopCoroutine(searchingWanderCoroutine);
				searchingWanderCoroutine = null;
			}
		}
	}
	public class MissionControlState : AIState
	{
		[CompilerGenerated]
		private sealed class <>c__DisplayClass43_0
		{
			public float startTime;

			public PlayerControllerB playerControllerB;

			public MissionControlState <>4__this;

			internal bool <MissionSurveillanceRoutine>b__0()
			{
				if (!((Object)(object)<>4__this.targetedPlayer != (Object)(object)StartOfRound.Instance.mapScreen.targetedPlayer))
				{
					return Time.timeSinceLevelLoad - startTime > 1f;
				}
				return true;
			}

			internal bool <MissionSurveillanceRoutine>b__1()
			{
				if (!((Object)(object)StartOfRound.Instance.mapScreen.targetedPlayer == (Object)(object)playerControllerB))
				{
					return Time.timeSinceLevelLoad - startTime > 3f;
				}
				return true;
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass49_0
		{
			public float startTime;

			public MissionControlState <>4__this;

			internal bool <UseSignalTranslator>b__0()
			{
				if (!<>4__this.targetPlayerUpdated)
				{
					return Time.timeSinceLevelLoad - startTime > 1f;
				}
				return true;
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass54_0
		{
			public Item item;

			internal bool <PurchaseItem>b__0(Item x)
			{
				if ((Object)(object)x != (Object)null)
				{
					return x.itemName == item.itemName;
				}
				return false;
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass58_0
		{
			public float startTime;

			public PlayerControllerB playerControllerB;

			public MissionControlState <>4__this;

			internal bool <UseTerminalInOrbit>b__0()
			{
				if (!((Object)(object)<>4__this.targetedPlayer != (Object)(object)StartOfRound.Instance.mapScreen.targetedPlayer))
				{
					return Time.timeSinceLevelLoad - startTime > 1f;
				}
				return true;
			}

			internal bool <UseTerminalInOrbit>b__1()
			{
				if (!((Object)(object)StartOfRound.Instance.mapScreen.targetedPlayer == (Object)(object)playerControllerB))
				{
					return Time.timeSinceLevelLoad - startTime > 3f;
				}
				return true;
			}
		}

		[CompilerGenerated]
		private sealed class <HandlePlayerMonitorLogic>d__47 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public MissionControlState <>4__this;

			public PlayerControllerB player;

			private float <startTime>5__2;

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

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

			[DebuggerHidden]
			public <HandlePlayerMonitorLogic>d__47(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0179: Unknown result type (might be due to invalid IL or missing references)
				//IL_0183: Expected O, but got Unknown
				//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
				int num = <>1__state;
				MissionControlState missionControlState = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<startTime>5__2 = Time.timeSinceLevelLoad;
					goto IL_0193;
				case 1:
					<>1__state = -1;
					if (player.isPlayerDead)
					{
						if (missionControlState.ShouldTeleportDeadBody(player))
						{
							<>2__current = missionControlState.TryTeleportPlayer(isDeadBody: true);
							<>1__state = 2;
							return true;
						}
						if (!((Object)(object)player.deadBody != (Object)null))
						{
							break;
						}
						DeadBodyInfo deadBody = player.deadBody;
						if (!deadBody.isInShip && !deadBody.grabBodyObject.isInShipRoom)
						{
							Bounds bounds = StartOfRound.Instance.shipInnerRoomBounds.bounds;
							if (((Bounds)(ref bounds)).Contains(((Component)deadBody).transform.position) && missionControlState.ai.IsGrabbableObjectGrabbable(deadBody.grabBodyObject))
							{
								missionControlState.bodyToCollect = deadBody.grabBodyObject;
							}
						}
						break;
					}
					if (player.isInElevator || player.isInHangarShipRoom)
					{
						break;
					}
					if (missionControlState.IsPlayerInGraveDanger(player))
					{
						<>2__current = missionControlState.TryTeleportPlayer();
						<>1__state = 3;
						return true;
					}
					goto IL_0173;
				case 2:
					<>1__state = -1;
					break;
				case 3:
					<>1__state = -1;
					goto IL_0173;
				case 4:
					{
						<>1__state = -1;
						goto IL_0193;
					}
					IL_0173:
					<>2__current = (object)new WaitForSeconds(0.2f);
					<>1__state = 4;
					return true;
					IL_0193:
					if (Time.timeSinceLevelLoad - <startTime>5__2 < 1f)
					{
						<>2__current = missionControlState.UseTerminalAccessibleObjects(player);
						<>1__state = 1;
						return true;
					}
					break;
				}
				return false;
			}

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

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

		[CompilerGenerated]
		private sealed class <MissionSurveillanceRoutine>d__43 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public MissionControlState <>4__this;

			private <>c__DisplayClass43_0 <>8__1;

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

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

			[DebuggerHidden]
			public <MissionSurveillanceRoutine>d__43(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>8__1 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_01c8: Unknown result type (might be due to invalid IL or missing references)
				//IL_01d2: Expected O, but got Unknown
				//IL_009e: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a8: Expected O, but got Unknown
				int num = <>1__state;
				MissionControlState missionControlState = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = null;
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					break;
				case 2:
					<>1__state = -1;
					missionControlState.targetPlayerUpdated = true;
					if (missionControlState.HasMessageToSend() && (Object)(object)SignalTranslator != (Object)null && Time.realtimeSinceStartup - SignalTranslator.timeLastUsingSignalTranslator >= 8f)
					{
						string nextMessageToSend = missionControlState.GetNextMessageToSend();
						if (!string.IsNullOrWhiteSpace(nextMessageToSend))
						{
							<>2__current = missionControlState.SendCommandToTerminal($"transmit {nextMessageToSend}");
							<>1__state = 3;
							return true;
						}
					}
					goto IL_0121;
				case 3:
					<>1__state = -1;
					goto IL_0121;
				case 4:
					<>1__state = -1;
					<>8__1.startTime = Time.timeSinceLevelLoad;
					<>2__current = (object)new WaitUntil((Func<bool>)(() => (Object)(object)StartOfRound.Instance.mapScreen.targetedPlayer == (Object)(object)<>8__1.playerControllerB || Time.timeSinceLevelLoad - <>8__1.startTime > 3f));
					<>1__state = 5;
					return true;
				case 5:
					<>1__state = -1;
					goto IL_01e2;
				case 6:
					<>1__state = -1;
					break;
				case 7:
					<>1__state = -1;
					break;
				case 8:
					<>1__state = -1;
					break;
				case 9:
					<>1__state = -1;
					goto IL_029d;
				case 10:
					{
						<>1__state = -1;
						<>8__1 = null;
						break;
					}
					IL_029d:
					<>2__current = missionControlState.SwitchRadarTarget();
					<>1__state = 10;
					return true;
					IL_01e2:
					<>2__current = missionControlState.TryTeleportPlayer(isDeadBody: false, skipPostCheck: true);
					<>1__state = 6;
					return true;
					IL_0121:
					missionControlState.targetedPlayer = StartOfRound.Instance.mapScreen.targetedPlayer;
					if (missionControlState.playersRequstedTeleport.TryDequeue(out <>8__1.playerControllerB))
					{
						if ((Object)(object)<>8__1.playerControllerB == (Object)null)
						{
							break;
						}
						if ((Object)(object)<>8__1.playerControllerB != (Object)(object)missionControlState.targetedPlayer)
						{
							<>2__current = missionControlState.SwitchRadarTarget(<>8__1.playerControllerB);
							<>1__state = 4;
							return true;
						}
						goto IL_01e2;
					}
					if (IsValidRadarTarget(missionControlState.monitoredPlayer))
					{
						if ((Object)(object)missionControlState.targetedPlayer != (Object)(object)missionControlState.monitoredPlayer)
						{
							<>2__current = missionControlState.SwitchRadarTarget(missionControlState.monitoredPlayer);
							<>1__state = 7;
							return true;
						}
						<>2__current = missionControlState.HandlePlayerMonitorLogic(missionControlState.monitoredPlayer);
						<>1__state = 8;
						return true;
					}
					if (IsValidRadarTarget(missionControlState.targetedPlayer))
					{
						<>2__current = missionControlState.HandlePlayerMonitorLogic(missionControlState.targetedPlayer);
						<>1__state = 9;
						return true;
					}
					goto IL_029d;
				}
				if (missionControlState.ai.State != null && missionControlState.ai.State == missionControlState && missionControlState.npcController.Npc.inTerminalMenu)
				{
					<>8__1 = new <>c__DisplayClass43_0();
					<>8__1.<>4__this = missionControlState;
					<>8__1.startTime = Time.timeSinceLevelLoad;
					<>2__current = (object)new WaitUntil((Func<bool>)(() => (Object)(object)<>8__1.<>4__this.targetedPlayer != (Object)(object)StartOfRound.Instance.mapScreen.targetedPlayer || Time.timeSinceLevelLoad - <>8__1.startTime > 1f));
					<>1__state = 2;
					return true;
				}
				missionControlState.StopMonitoringCrew();
				return false;
			}

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

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

		[CompilerGenerated]
		private sealed class <PurchaseItem>d__54 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public Item item;

			public int numToPurchase;

			public bool overrideEcoLimit;

			public int ecoLimit;

			public MissionControlState <>4__this;

			private <>c__DisplayClass54_0 <>8__1;

			private Terminal <terminal>5__2;

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

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

			[DebuggerHidden]
			public <PurchaseItem>d__54(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>8__1 = null;
				<terminal>5__2 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				int num = <>1__state;
				MissionControlState missionControlState = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
				{
					<>1__state = -1;
					<>8__1 = new <>c__DisplayClass54_0();
					<>8__1.item = item;
					<terminal>5__2 = TerminalManager.Instance.GetTerminal();
					if ((Object)(object)<terminal>5__2 == (Object)null || numToPurchase <= 0)
					{
						return false;
					}
					int num2 = Array.FindIndex(<terminal>5__2.buyableItemsList, (Item x) => (Object)(object)x != (Object)null && x.itemName == <>8__1.item.itemName);
					if (num2 < 0)
					{
						return false;
					}
					int num3 = 12 - <terminal>5__2.numberOfItemsInDropship;
					if (num3 <= 0)
					{
						return false;
					}
					numToPurchase = Mathf.Min(numToPurchase, num3);
					int num4 = (int)((float)<terminal>5__2.buyableItemsList[num2].creditsWorth * ((float)<terminal>5__2.itemSalesPercentages[num2] / 100f));
					int num5 = num4 * numToPurchase;
					if (num5 > 0)
					{
						int num6 = (overrideEcoLimit ? ecoLimit : Plugin.Config.RestockEcoLimit.Value);
						int groupCredits = <terminal>5__2.groupCredits;
						int num7 = groupCredits - num6;
						if (num7 <= 0)
						{
							return false;
						}
						int val = num7 / num4;
						numToPurchase = Math.Min(numToPurchase, val);
						if (numToPurchase <= 0)
						{
							return false;
						}
					}
					if ((Object)(object)<terminal>5__2.currentNode != (Object)(object)<terminal>5__2.terminalNodes.specialNodes[13])
					{
						if (<terminal>5__2.currentNode.isConfirmationNode)
						{
							<>2__current = missionControlState.SendCommandToTerminal("deny");
							<>1__state = 1;
							return true;
						}
						goto IL_01c1;
					}
					goto IL_01e2;
				}
				case 1:
					<>1__state = -1;
					goto IL_01c1;
				case 2:
					<>1__state = -1;
					goto IL_01e2;
				case 3:
					<>1__state = -1;
					<>2__current = missionControlState.SendCommandToTerminal($"buy {<>8__1.item.itemName} {numToPurchase}");
					<>1__state = 4;
					return true;
				case 4:
					<>1__state = -1;
					if (!<terminal>5__2.currentNode.isConfirmationNode)
					{
						Plugin.LogWarning("Bot " + missionControlState.npcController.Npc.playerUsername + " attempted to buy " + <>8__1.item.itemName + ", but it failed?");
						return false;
					}
					<>2__current = missionControlState.SendCommandToTerminal("confirm");
					<>1__state = 5;
					return true;
				case 5:
					{
						<>1__state = -1;
						return false;
					}
					IL_01e2:
					<>2__current = missionControlState.SendCommandToTerminal("store");
					<>1__state = 3;
					return true;
					IL_01c1:
					<>2__current = missionControlState.SendCommandToTerminal("help");
					<>1__state = 2;
					return true;
				}
			}

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

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

		[CompilerGenerated]
		private sealed class <RestockTheShip>d__53 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public MissionControlState <>4__this;

			private Terminal <ourTerminal>5__2;

			private LethalBotStockRequirement[] <>7__wrap2;

			private int <>7__wrap3;

			private LethalBotStockRequirement <stockRequirement>5__5;

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

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

			[DebuggerHidden]
			public <RestockTheShip>d__53(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<ourTerminal>5__2 = null;
				<>7__wrap2 = null;
				<stockRequirement>5__5 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_005a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0064: Expected O, but got Unknown
				int num = <>1__state;
				MissionControlState missionControlState = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = null;
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					break;
				case 2:
					<>1__state = -1;
					missionControlState.canCollectPurchasedItems = false;
					<ourTerminal>5__2 = TerminalManager.Instance.GetTerminal();
					<>7__wrap2 = RestockManager.Instance.LethalBotStockRequirements;
					<>7__wrap3 = 0;
					goto IL_0204;
				case 3:
					<>1__state = -1;
					if (<stockRequirement>5__5 != null && !((Object)(object)<stockRequirement>5__5.Item == (Object)null))
					{
						Item item = <stockRequirement>5__5.Item;
						int requiredStock = <stockRequirement>5__5.RequiredStock;
						if (requiredStock > 0)
						{
							int num2 = missionControlState.GetPendingOrderCount(item, <ourTerminal>5__2, CollectPurchasedItemsState.ItemDropship) + missionControlState.GetNumberOfItemAlreadyOwned(item);
							int num3 = requiredStock - num2;
							if (num3 > 0)
							{
								bool flag = true;
								if (<stockRequirement>5__5.RequiredItems.Count > 0)
								{
									foreach (LethalBotStockRequiredItem requiredItem in <stockRequirement>5__5.RequiredItems)
									{
										if ((Object)(object)requiredItem.Item != (Object)null && (!missionControlState.FindItemWithName(requiredItem.Name, out var numFound) || numFound < requiredItem.RequiredStock))
										{
											flag = false;
											break;
										}
									}
								}
								if (flag)
								{
									<>2__current = missionControlState.PurchaseItem(item, num3, <stockRequirement>5__5.OverrideEcoLimit, <stockRequirement>5__5.EcoLimit);
									<>1__state = 4;
									return true;
								}
							}
							goto IL_01ef;
						}
					}
					goto IL_01f6;
				case 4:
					{
						<>1__state = -1;
						goto IL_01ef;
					}
					IL_01ef:
					<stockRequirement>5__5 = null;
					goto IL_01f6;
					IL_01f6:
					<>7__wrap3++;
					goto IL_0204;
					IL_0204:
					if (<>7__wrap3 < <>7__wrap2.Length)
					{
						<stockRequirement>5__5 = <>7__wrap2[<>7__wrap3];
						<>2__current = null;
						<>1__state = 3;
						return true;
					}
					<>7__wrap2 = null;
					<ourTerminal>5__2 = null;
					break;
				}
				if (missionControlState.ai.State != null && missionControlState.ai.State == missionControlState && missionControlState.npcController.Npc.inTerminalMenu && LethalBotManager.AreWeAtTheCompanyBuilding())
				{
					missionControlState.canCollectPurchasedItems = true;
					<>2__current = (object)new WaitForSeconds(1f);
					<>1__state = 2;
					return true;
				}
				missionControlState.StopRestockingTheShip();
				return false;
			}

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

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

		[CompilerGenerated]
		private sealed class <RouteToMoon>d__59 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public string moonName;

			public MissionControlState <>4__this;

			private Terminal <terminal>5__2;

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

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

			[DebuggerHidden]
			public <RouteToMoon>d__59(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<terminal>5__2 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				int num = <>1__state;
				MissionControlState missionControlState = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
				{
					<>1__state = -1;
					<terminal>5__2 = TerminalManager.Instance.GetTerminal();
					if ((Object)(object)<terminal>5__2 == (Object)null || string.IsNullOrWhiteSpace(moonName))
					{
						return false;
					}
					StartOfRound instance = StartOfRound.Instance;
					if (!instance.inShipPhase || instance.travellingToNewLevel)
					{
						return false;
					}
					if ((Object)(object)<terminal>5__2.currentNode != (Object)(object)<terminal>5__2.terminalNodes.specialNodes[13])
					{
						if (<terminal>5__2.currentNode.isConfirmationNode)
						{
							<>2__current = missionControlState.SendCommandToTerminal("deny");
							<>1__state = 1;
							return true;
						}
						goto IL_00d6;
					}
					goto IL_00f7;
				}
				case 1:
					<>1__state = -1;
					goto IL_00d6;
				case 2:
					<>1__state = -1;
					goto IL_00f7;
				case 3:
					<>1__state = -1;
					<>2__current = missionControlState.SendCommandToTerminal($"route {moonName}");
					<>1__state = 4;
					return true;
				case 4:
				{
					<>1__state = -1;
					TerminalNode currentNode = <terminal>5__2.currentNode;
					if (currentNode.displayPlanetInfo == -1 && moonName.ToLower() != "The Company building".ToLower())
					{
						Plugin.LogWarning("Bot " + missionControlState.npcController.Npc.playerUsername + " attempted to route to " + moonName + ", but it failed?");
						return false;
					}
					<>2__current = missionControlState.SendCommandToTerminal("confirm");
					<>1__state = 5;
					return true;
				}
				case 5:
					{
						<>1__state = -1;
						return false;
					}
					IL_00f7:
					<>2__current = missionControlState.SendCommandToTerminal("moons");
					<>1__state = 3;
					return true;
					IL_00d6:
					<>2__current = missionControlState.SendCommandToTerminal("help");
					<>1__state = 2;
					return true;
				}
			}

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

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

		[CompilerGenerated]
		private sealed class <SendCommandToTerminal>d__48 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public string command;

			private Terminal <ourTerminal>5__2;

			private int <i>5__3;

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

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

			[DebuggerHidden]
			public <SendCommandToTerminal>d__48(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<ourTerminal>5__2 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0099: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a3: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					command = command.Trim();
					if (string.IsNullOrWhiteSpace(command))
					{
						return false;
					}
					<ourTerminal>5__2 = TerminalManager.Instance.GetTerminal();
					<i>5__3 = 0;
					break;
				case 1:
					<>1__state = -1;
					<i>5__3++;
					break;
				}
				if (<i>5__3 < command.Length + 1)
				{
					if ((Object)(object)<ourTerminal>5__2 != (Object)null)
					{
						RoundManager.PlayRandomClip(<ourTerminal>5__2.terminalAudio, <ourTerminal>5__2.keyboardClips, true, 1f, 0, 1000);
					}
					<>2__current = (object)new WaitForSeconds(Random.Range(0.05f, 0.3f));
					<>1__state = 1;
					return true;
				}
				TerminalManager.Instance.OnSubmit(command, <ourTerminal>5__2);
				return false;
			}

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

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

		[CompilerGenerated]
		private sealed class <SwitchRadarTarget>d__44 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public PlayerControllerB player;

			public MissionControlState <>4__this;

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

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

			[DebuggerHidden]
			public <SwitchRadarTarget>d__44(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				int num = <>1__state;
				MissionControlState missionControlState = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					if ((Object)(object)player != (Object)null)
					{
						string text = player.playerUsername.ToLower();
						<>2__current = missionControlState.SendCommandToTerminal("switch " + text);
						<>1__state = 1;
						return true;
					}
					<>2__current = missionControlState.SendCommandToTerminal("switch");
					<>1__state = 2;
					return true;
				case 1:
					<>1__state = -1;
					break;
				case 2:
					<>1__state = -1;
					break;
				}
				return false;
			}

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

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

		[CompilerGenerated]
		private sealed class <TryTeleportPlayer>d__46 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public bool isDeadBody;

			public bool skipPostCheck;

			public MissionControlState <>4__this;

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

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

			[DebuggerHidden]
			public <TryTeleportPlayer>d__46(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ce: Expected O, but got Unknown
				//IL_008a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0094: Expected O, but got Unknown
				int num = <>1__state;
				MissionControlState missionControlState = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					if (!((Object)(object)ShipTeleporter != (Object)null) || (isDeadBody && !ShipTeleporter.buttonTrigger.interactable))
					{
						break;
					}
					if (!ShipTeleporter.buttonAnimator.GetBool("GlassOpen"))
					{
						ShipTeleporter.buttonAnimator.SetBool("GlassOpen", true);
						<>2__current = (object)new WaitForSeconds(0.5f);
						<>1__state = 1;
						return true;
					}
					goto IL_00a4;
				case 1:
					<>1__state = -1;
					goto IL_00a4;
				case 2:
					<>1__state = -1;
					<>2__current = null;
					<>1__state = 3;
					return true;
				case 3:
					{
						<>1__state = -1;
						PlayerControllerB targetedPlayer = StartOfRound.Instance.mapScreen.targetedPlayer;
						if ((Object)(object)targetedPlayer != (Object)null && !skipPostCheck)
						{
							if (isDeadBody)
							{
								if (!missionControlState.ShouldTeleportDeadBody(targetedPlayer))
								{
									return false;
								}
							}
							else if (!missionControlState.IsPlayerInGraveDanger(targetedPlayer))
							{
								return false;
							}
						}
						ShipTeleporter.PressTeleportButtonOnLocalClient();
						break;
					}
					IL_00a4:
					<>2__current = (object)new WaitUntil((Func<bool>)(() => ShipTeleporter.buttonTrigger.interactable));
					<>1__state = 2;
					return true;
				}
				return false;
			}

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

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

		[CompilerGenerated]
		private sealed class <UseSignalTranslator>d__49 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public MissionControlState <>4__this;

			private RoundManager <instanceRM>5__2;

			private Vector3 <playerPos>5__3;

			private int <i>5__4;

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

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

			[DebuggerHidden]
			public <UseSignalTranslator>d__49(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<instanceRM>5__2 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
				//IL_0119: Unknown result type (might be due to invalid IL or missing references)
				//IL_011e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0251: Unknown result type (might be due to invalid IL or missing references)
				//IL_0256: Unknown result type (might be due to invalid IL or missing references)
				//IL_0258: Unknown result type (might be due to invalid IL or missing references)
				//IL_025d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0266: Unknown result type (might be due to invalid IL or missing references)
				//IL_0072: Unknown result type (might be due to invalid IL or missing references)
				//IL_007c: Expected O, but got Unknown
				//IL_01a5: Unknown result type (might be due to invalid IL or missing references)
				//IL_01ab: Unknown result type (might be due to invalid IL or missing references)
				//IL_01b0: Unknown result type (might be due to invalid IL or missing references)
				//IL_01b5: Unknown result type (might be due to invalid IL or missing references)
				int num = <>1__state;
				MissionControlState missionControlState = <>4__this;
				TimeOfDay instance;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = null;
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					break;
				case 2:
					<>1__state = -1;
					missionControlState.targetPlayerUpdated = false;
					if ((Object)(object)missionControlState.targetedPlayer == (Object)null)
					{
						break;
					}
					<instanceRM>5__2 = RoundManager.Instance;
					<playerPos>5__3 = ((Component)missionControlState.targetedPlayer).transform.position;
					if ((Object)(object)missionControlState.targetedPlayer.redirectToEnemy != (Object)null)
					{
						<playerPos>5__3 = ((Component)missionControlState.targetedPlayer.redirectToEnemy).transform.position;
					}
					else if ((Object)(object)missionControlState.targetedPlayer.deadBody != (Object)null)
					{
						<playerPos>5__3 = ((Component)missionControlState.targetedPlayer.deadBody).transform.position;
					}
					<i>5__4 = 0;
					goto IL_0219;
				case 3:
					<>1__state = -1;
					<i>5__4++;
					goto IL_0219;
				case 4:
					{
						<>1__state = -1;
						<instanceRM>5__2 = null;
						break;
					}
					IL_0219:
					if (<i>5__4 < <instanceRM>5__2.SpawnedEnemies.Count)
					{
						EnemyAI val = <instanceRM>5__2.SpawnedEnemies[<i>5__4];
						string enemyName = GetEnemyName(val);
						if (!val.isEnemyDead && (!missionControlState.calledOutEnemies.TryGetValue(enemyName, out var value) || Time.timeSinceLevelLoad - value > 60f) && (missionControlState.ai.GetFearRangeForEnemies(val).HasValue || IsEnemy(val)))
						{
							Vector3 val2 = ((Component)val).transform.position - <playerPos>5__3;
							if (((Vector3)(ref val2)).sqrMagnitude < 1600f)
							{
								missionControlState.calledOutEnemies[enemyName] = Time.timeSinceLevelLoad;
								QueuePriority priority = ((!(val is JesterAI)) ? QueuePriority.Low : QueuePriority.Critical);
								missionControlState.SendMessageUsingSignalTranslator(enemyName, priority);
							}
						}
						<>2__current = null;
						<>1__state = 3;
						return true;
					}
					instance = TimeOfDay.Instance;
					if ((Object)(object)instance != (Object)null)
					{
						DayMode dayPhase = instance.GetDayPhase(instance.currentDayTime / instance.totalTime);
						if (LethalBotManager.lastReportedTimeOfDay != dayPhase)
						{
							LethalBotManager.Instance.SetLastReportedTimeOfDayAndSync(dayPhase);
							missionControlState.SendMessageUsingSignalTranslator(GetCurrentTime(instance.normalizedTimeOfDay, instance.numberOfHours, createNewLine: false), QueuePriority.Normal);
						}
					}
					<>2__current = null;
					<>1__state = 4;
					return true;
				}
				if (missionControlState.ai.State != null && missionControlState.ai.State == missionControlState && missionControlState.npcController.Npc.inTerminalMenu && (Object)(object)SignalTranslator != (Object)null)
				{
					<>2__current = (object)new WaitUntil((Func<bool>)new <>c__DisplayClass49_0
					{
						<>4__this = missionControlState,
						startTime = Time.timeSinceLevelLoad
					}.<UseSignalTranslator>b__0);
					<>1__state = 2;
					return true;
				}
				missionControlState.StopUsingSignalTranslator();
				return false;
			}

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

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

		[CompilerGenerated]
		private sealed class <UseTerminalAccessibleObjects>d__45 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public PlayerControllerB player;

			public MissionControlState <>4__this;

			private TerminalAccessibleObject[] <>7__wrap1;

			private int <>7__wrap2;

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

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

			[DebuggerHidden]
			public <UseTerminalAccessibleObjects>d__45(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>7__wrap1 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				int num = <>1__state;
				MissionControlState missionControlState = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
				{
					<>1__state = -1;
					TerminalAccessibleObject[] array = FindTerminalAccessibleObjectsToUse(player);
					<>7__wrap1 = array;
					<>7__wrap2 = 0;
					break;
				}
				case 1:
					<>1__state = -1;
					<>7__wrap2++;
					break;
				}
				if (<>7__wrap2 < <>7__wrap1.Length)
				{
					TerminalAccessibleObject val = <>7__wrap1[<>7__wrap2];
					<>2__current = missionControlState.SendCommandToTerminal(val.objectCode);
					<>1__state = 1;
					return true;
				}
				<>7__wrap1 = null;
				return false;
			}

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

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

		[CompilerGenerated]
		private sealed class <UseTerminalInOrbit>d__58 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public MissionControlState <>4__this;

			private <>c__DisplayClass58_0 <>8__1;

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

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

			[DebuggerHidden]
			public <UseTerminalInOrbit>d__58(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>8__1 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_024b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0255: Expected O, but got Unknown
				//IL_0121: Unknown result type (might be due to invalid IL or missing references)
				//IL_012b: Expected O, but got Unknown
				//IL_0082: Unknown result type (might be due to invalid IL or missing references)
				//IL_008c: Expected O, but got Unknown
				int num = <>1__state;
				MissionControlState missionControlState = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = null;
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					break;
				case 2:
					<>1__state = -1;
					if (Plugin.Config.AutoRouteToCompany.Value)
					{
						TimeOfDay instance = TimeOfDay.Instance;
						if ((Object)(object)instance != (Object)null && instance.daysUntilDeadline <= 0 && StartOfRound.Instance.currentLevel.planetHasTime && !LethalBotManager.AreWeAtTheCompanyBuilding(checkOrbit: false))
						{
							<>2__current = missionControlState.RouteToMoon("The Company building");
							<>1__state = 3;
							return true;
						}
					}
					goto IL_00ff;
				case 3:
					<>1__state = -1;
					goto IL_00ff;
				case 4:
					<>1__state = -1;
					missionControlState.targetPlayerUpdated = true;
					if (missionControlState.HasMessageToSend() && (Object)(object)SignalTranslator != (Object)null && Time.realtimeSinceStartup - SignalTranslator.timeLastUsingSignalTranslator >= 8f)
					{
						string nextMessageToSend = missionControlState.GetNextMessageToSend();
						if (!string.IsNullOrWhiteSpace(nextMessageToSend))
						{
							<>2__current = missionControlState.SendCommandToTerminal($"transmit {nextMessageToSend}");
							<>1__state = 5;
							return true;
						}
					}
					goto IL_01a4;
				case 5:
					<>1__state = -1;
					goto IL_01a4;
				case 6:
					<>1__state = -1;
					<>8__1.startTime = Time.timeSinceLevelLoad;
					<>2__current = (object)new WaitUntil((Func<bool>)(() => (Object)(object)StartOfRound.Instance.mapScreen.targetedPlayer == (Object)(object)<>8__1.playerControllerB || Time.timeSinceLevelLoad - <>8__1.startTime > 3f));
					<>1__state = 7;
					return true;
				case 7:
					<>1__state = -1;
					goto IL_0265;
				case 8:
					<>1__state = -1;
					break;
				case 9:
					<>1__state = -1;
					goto IL_02ed;
				case 10:
					{
						<>1__state = -1;
						goto IL_02ed;
					}
					IL_00ff:
					<>8__1.startTime = Time.timeSinceLevelLoad;
					<>2__current = (object)new WaitUntil((Func<bool>)(() => (Object)(object)<>8__1.<>4__this.targetedPlayer != (Object)(object)StartOfRound.Instance.mapScreen.targetedPlayer || Time.timeSinceLevelLoad - <>8__1.startTime > 1f));
					<>1__state = 4;
					return true;
					IL_01a4:
					missionControlState.targetedPlayer = StartOfRound.Instance.mapScreen.targetedPlayer;
					if (missionControlState.playersRequstedTeleport.TryDequeue(out <>8__1.playerControllerB))
					{
						if ((Object)(object)<>8__1.playerControllerB == (Object)null)
						{
							break;
						}
						if ((Object)(object)<>8__1.playerControllerB != (Object)(object)missionControlState.targetedPlayer)
						{
							<>2__current = missionControlState.SwitchRadarTarget(<>8__1.playerControllerB);
							<>1__state = 6;
							return true;
						}
						goto IL_0265;
					}
					if (IsValidRadarTarget(missionControlState.monitoredPlayer))
					{
						if ((Object)(object)missionControlState.targetedPlayer != (Object)(object)missionControlState.monitoredPlayer)
						{
							<>2__current = missionControlState.SwitchRadarTarget(missionControlState.monitoredPlayer);
							<>1__state = 9;
							return true;
						}
						<>2__current = missionControlState.HandlePlayerMonitorLogic(missionControlState.monitoredPlayer);
						<>1__state = 10;
						return true;
					}
					goto IL_02ed;
					IL_02ed:
					<>8__1 = null;
					break;
					IL_0265:
					<>2__current = missionControlState.TryTeleportPlayer(isDeadBody: false, skipPostCheck: true);
					<>1__state = 8;
					return true;
				}
				if (missionControlState.ai.State != null && missionControlState.ai.State == missionControlState && missionControlState.npcController.Npc.inTerminalMenu && LethalBotManager.AreWeInOrbit())
				{
					<>8__1 = new <>c__DisplayClass58_0();
					<>8__1.<>4__this = missionControlState;
					<>2__current = (object)new WaitForSeconds(1f);
					<>1__state = 2;
					return true;
				}
				missionControlState.StopOrbitLogic();
				return false;
			}

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

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

		private bool overrideCrouch;

		private bool skipTerminalThink;

		private bool canCollectPurchasedItems;

		private bool grabbedLoadout;

		private bool botClosedShipDoors;

		private bool playerRequestLeave;

		private bool playerRequestedTerminal;

		private float waitForTerminalTime;

		private bool targetPlayerUpdated;

		private WalkieTalkie? walkieTalkie;

		private GrabbableObject? weapon;

		private GrabbableObject? bodyToCollect;

		private PlayerControllerB? targetedPlayer;

		private PlayerControllerB? monitoredPlayer;

		private Queue<PlayerControllerB> playersRequstedTeleport = new Queue<PlayerControllerB>();

		private Coroutine? monitorCrew;

		private Coroutine? useSignalTranslator;

		private Coroutine? restockShip;

		private Coroutine? orbitLogic;

		private float leavePlanetTimer;

		private static Dictionary<Turret, TerminalAccessibleObject> turrets = new Dictionary<Turret, TerminalAccessibleObject>();

		private static Dictionary<Landmine, TerminalAccessibleObject> landmines = new Dictionary<Landmine, TerminalAccessibleObject>();

		private static Dictionary<SpikeRoofTrap, TerminalAccessibleObject> spikeRoofTraps = new Dictionary<SpikeRoofTrap, TerminalAccessibleObject>();

		private Dictionary<string, float> calledOutEnemies = new Dictionary<string, float>();

		private PriorityQueue<string> messageQueue = new PriorityQueue<string>();

		private static readonly FieldRef<TerminalAccessibleObject, bool> isDoorOpen = (FieldRef<TerminalAccessibleObject, bool>)(object)AccessTools.FieldRefAccess<bool>(typeof(TerminalAccessibleObject), "isDoorOpen");

		private static readonly FieldRef<TerminalAccessibleObject, bool> inCooldown = (FieldRef<TerminalAccessibleObject, bool>)(object)AccessTools.FieldRefAccess<bool>(typeof(TerminalAccessibleObject), "inCooldown");

		[CompilerGenerated]
		private static ShipTeleporter? <ShipTeleporter>k__BackingField;

		[CompilerGenerated]
		private static SignalTranslator? <SignalTranslator>k__BackingField;

		[CompilerGenerated]
		private static ShipAlarmCord? <ShipHorn>k__BackingField;

		private static ShipTeleporter? ShipTeleporter
		{
			get
			{
				if ((Object)(object)<ShipTeleporter>k__BackingField == (Object)null)
				{
					<ShipTeleporter>k__BackingField = LethalBotAI.FindTeleporter();
				}
				return <ShipTeleporter>k__BackingField;
			}
		}

		internal static SignalTranslator? SignalTranslator
		{
			get
			{
				if ((Object)(object)<SignalTranslator>k__BackingField == (Object)null)
				{
					<SignalTranslator>k__BackingField = Object.FindObjectOfType<SignalTranslator>();
				}
				return <SignalTranslator>k__BackingField;
			}
		}

		private static ShipAlarmCord? ShipHorn
		{
			get
			{
				if ((Object)(object)<ShipHorn>k__BackingField == (Object)null)
				{
					<ShipHorn>k__BackingField = Object.FindObjectOfType<ShipAlarmCord>();
				}
				return <ShipHorn>k__BackingField;
			}
		}

		public MissionControlState(AIState oldState)
			: base(oldState)
		{
			base.CurrentState = EnumAIStates.MissionControl;
		}

		public MissionControlState(LethalBotAI ai)
			: base(ai)
		{
			base.CurrentState = EnumAIStates.MissionControl;
		}

		public override void OnEnterState()
		{
			if (!hasBeenStarted)
			{
				PlayerControllerB missionControlPlayer = LethalBotManager.Instance.MissionControlPlayer;
				if ((Object)(object)missionControlPlayer == (Object)null || !missionControlPlayer.isPlayerControlled || missionControlPlayer.isPlayerDead)
				{
					LethalBotManager.Instance.MissionControlPlayer = npcController.Npc;
				}
				SetupTerminalAccessibleObjects();
				FindWalkieTalkie();
				FindWeapon();
				grabbedLoadout = false;
			}
			if ((Object)(object)LethalBotManager.Instance.MissionControlPlayer == (Object)(object)npcController.Npc && GroupManager.Instance.IsPlayerInGroup(npcController.Npc))
			{
				GroupManager.Instance.RemoveFromCurrentGroupAndSync(npcController.Npc);
			}
			base.OnEnterState();
		}

		public override void OnExitState(AIState newState)
		{
			EnumAIStates aIState = newState.GetAIState();
			if ((uint)(aIState - 2) <= 2u || aIState == EnumAIStates.PlayerInCruiser)
			{
				LethalBotManager.Instance.MissionControlPlayer = null;
			}
			if (Plugin.IsModLethalPhonesLoaded && (Object)(object)LethalBotManager.Instance.MissionControlPlayer != (Object)(object)npcController.Npc)
			{
				base.ai.StopBeingSwitchboardOperator();
			}
			base.OnExitState(newState);
		}

		public override void DoAI()
		{
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_0229: Unknown result type (might be due to invalid IL or missing references)
			//IL_022f: Unknown result type (might be due to invalid IL or missing references)
			//IL_06be: Unknown result type (might be due to invalid IL or missing references)
			//IL_06d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_06d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_06dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_06fe: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)LethalBotManager.Instance.MissionControlPlayer != (Object)(object)npcController.Npc || (!Plugin.Config.AllowBotsInOrbit.Value && StartOfRound.Instance.shipIsLeaving))
			{
				GetOffTerminal();
				if (!Plugin.Config.AllowBotsInOrbit.Value && StartOfRound.Instance.shipIsLeaving)
				{
					LethalBotManager.Instance.MissionControlPlayer = null;
				}
				base.ai.State = new ChillAtShipState(this);
				return;
			}
			if (LethalBotManager.Instance.LootTransferPlayers.Contains(NetworkBehaviourReference.op_Implicit((NetworkBehaviour)(object)npcController.Npc)))
			{
				LethalBotManager.Instance.RemovePlayerFromLootTransferListAndSync(NetworkBehaviourReference.op_Implicit((NetworkBehaviour)(object)npcController.Npc));
			}
			if (GroupManager.Instance.IsPlayerInGroup(npcController.Npc))
			{
				GroupManager.Instance.RemoveFromCurrentGroupAndSync(npcController.Npc);
			}
			if (!npcController.Npc.isInElevator && !npcController.Npc.isInHangarShipRoom)
			{
				base.ai.State = new ReturnToShipState(this);
				return;
			}
			if (!grabbedLoadout)
			{
				grabbedLoadout = true;
				base.ai.State = new GrabLoadoutState(this);
				return;
			}
			if (playerRequestedTerminal)
			{
				if (!GetOffTerminal())
				{
					if (waitForTerminalTime > 5f)
					{
						playerRequestedTerminal = false;
						waitForTerminalTime = 0f;
					}
					else
					{
						waitForTerminalTime += ((EnemyAI)base.ai).AIIntervalTime;
					}
				}
				return;
			}
			waitForTerminalTime = 0f;
			PlayerControllerB val = base.ai.LookingForPlayerToRevive(ignoreLOS: true, shipOnly: true);
			if ((Object)(object)val != (Object)null)
			{
				if (!GetOffTerminal())
				{
					base.ai.State = new RescueAndReviveState(this, val);
				}
				return;
			}
			val = base.ai.LookingForPlayerToHeal(ignoreLOS: true, shipOnly: true);
			if ((Object)(object)val != (Object)null)
			{
				if (!GetOffTerminal())
				{
					base.ai.State = new HealPlayerState(this, val);
				}
				return;
			}
			Vector3 placePosition;
			if (!base.ai.AreHandsFree() && FindObject(base.ai.HeldItem))
			{
				if (!GetOffTerminal())
				{
					LethalBotAI lethalBotAI = base.ai;
					placePosition = default(Vector3);
					lethalBotAI.DropItem(placeObject: false, null, placePosition);
				}
				return;
			}
			if (base.ai.HasGrabbableObjectInInventory((Func<GrabbableObject, bool>)FindObject, out int objectSlot))
			{
				if (!GetOffTerminal())
				{
					base.ai.SwitchItemSlotsAndSync(objectSlot);
				}
				return;
			}
			GrabbableObject val2 = bodyToCollect;
			if ((Object)(object)val2 != (Object)null)
			{
				if (!GetOffTerminal())
				{
					bodyToCollect = null;
					LethalBotAI.DictJustDroppedItems.Remove(val2);
					base.ai.State = new FetchingObjectState(this, val2);
				}
				return;
			}
			if (canCollectPurchasedItems && CollectPurchasedItemsState.IsPossible())
			{
				GetOffTerminal();
				base.ai.State = new CollectPurchasedItemsState(this);
				return;
			}
			if (LethalBotManager.AreWeAtTheCompanyBuilding())
			{
				if ((Object)(object)base.ai.LookingForObjectsToSell(ignoreHeldFlag: true) != (Object)null || LethalBotManager.AreThereItemsOnDesk())
				{
					if (!GetOffTerminal())
					{
						base.ai.State = new CollectScrapToSellState(this);
					}
					return;
				}
				if ((playerRequestLeave || LethalBotManager.Instance.AreAllHumanPlayersDead()) && LethalBotManager.Instance.AreAllPlayersOnTheShip())
				{
					if (leavePlanetTimer > 5f)
					{
						if (GetOffTerminal())
						{
							return;
						}
						StartOfRound playersManager = npcController.Npc.playersManager;
						if ((LethalBotManager.IsTheShipLanded(playersManager) || LethalBotManager.AreWeInOrbit(playersManager)) && !LethalBotManager.IsTheShipLeaving(playersManager))
						{
							StartMatchLever val3 = Object.FindObjectOfType<StartMatchLever>();
							if ((Object)(object)val3 != (Object)null)
							{
								base.ai.PullShipLever(val3);
								playerRequestLeave = false;
							}
						}
					}
					else
					{
						leavePlanetTimer += ((EnemyAI)base.ai).AIIntervalTime;
					}
					return;
				}
				leavePlanetTimer = 0f;
			}
			else
			{
				bool flag = LethalBotManager.IsShipCompromised(base.ai);
				if (playerRequestLeave || (ShouldReturnToShip() && LethalBotManager.Instance.AreAllPlayersOnTheShip(bypassCooldown: true) && (LethalBotManager.Instance.AreAllHumanPlayersDead(bypassCooldown: true) || flag)))
				{
					if (leavePlanetTimer > 5f || flag)
					{
						if (GetOffTerminal())
						{
							return;
						}
						StartOfRound playersManager2 = npcController.Npc.playersManager;
						if ((LethalBotManager.IsTheShipLanded(playersManager2) || LethalBotManager.AreWeInOrbit(playersManager2)) && !LethalBotManager.IsTheShipLeaving(playersManager2))
						{
							StartMatchLever val4 = Object.FindObjectOfType<StartMatchLever>();
							if ((Object)(object)val4 != (Object)null)
							{
								base.ai.PullShipLever(val4);
								playerRequestLeave = false;
							}
						}
					}
					else
					{
						leavePlanetTimer += ((EnemyAI)base.ai).AIIntervalTime;
					}
					return;
				}
				leavePlanetTimer = 0f;
				if ((Object)(object)weapon != (Object)null)
				{
					if (!base.ai.HasGrabbableObjectInInventory(weapon, out var _))
					{
						int num = base.ai.FirstEmptyItemSlot(weapon);
						if (num != -1)
						{
							if (!weapon.isInShipRoom || weapon.isHeld)
							{
								FindWeapon();
								return;
							}
							LethalBotAI.DictJustDroppedItems.Remove(weapon);
							base.ai.State = new FetchingObjectState(this, weapon);
							return;
						}
						weapon = null;
					}
					else
					{
						if (!LethalBotAI.IsItemPowered(weapon))
						{
							base.ai.State = new ChargeHeldItemState(this, weapon);
							return;
						}
						EnemyAI val5 = CheckForInvadingEnemy();
						if ((Object)(object)val5 != (Object)null)
						{
							base.ai.State = new FightEnemyState(this, val5);
							return;
						}
					}
				}
			}
			Terminal terminal = TerminalManager.Instance.GetTerminal();
			if ((Object)(object)terminal == (Object)null)
			{
				return;
			}
			if ((Object)(object)walkieTalkie != (Object)null)
			{
				if (!base.ai.HasGrabbableObjectInInventory((GrabbableObject?)(object)walkieTalkie, out var objectSlot3))
				{
					int num2 = base.ai.FirstEmptyItemSlot((GrabbableObject?)(object)walkieTalkie);
					if (num2 != -1)
					{
						if (!((GrabbableObject)walkieTalkie).isInShipRoom || ((GrabbableObject)walkieTalkie).isHeld)
						{
							FindWalkieTalkie();
							return;
						}
						LethalBotAI.DictJustDroppedItems.Remove((GrabbableObject)(object)walkieTalkie);
						base.ai.State = new FetchingObjectState(this, (GrabbableObject?)(object)walkieTalkie);
						return;
					}
					walkieTalkie = null;
				}
				else
				{
					if (((GrabbableObject)walkieTalkie).insertedBattery.empty || ((GrabbableObject)walkieTalkie).insertedBattery.charge < 0.1f)
					{
						base.ai.State = new ChargeHeldItemState(this, (GrabbableObject?)(object)walkieTalkie);
						return;
					}
					if ((Object)(object)walkieTalkie != (Object)null && (Object)(object)base.ai.HeldItem != (Object)(object)walkieTalkie)
					{
						base.ai.SwitchItemSlotsAndSync(objectSlot3);
						return;
					}
				}
			}
			ref InteractTrigger reference = ref PatchesUtil.terminalTriggerField.Invoke(terminal);
			placePosition = reference.playerPositionNode.position - ((Component)npcController.Npc).transform.position;
			float sqrMagnitude = ((Vector3)(ref placePosition)).sqrMagnitude;
			if (sqrMagnitude > 1f)
			{
				base.ai.SetDestinationToPositionLethalBotAI(reference.playerPositionNode.position);
				overrideCrouch = false;
				if (!npcController.WaitForFullStamina && sqrMagnitude > 64f)
				{
					npcController.OrderToSprint();
				}
				else if (npcController.WaitForFullStamina || sqrMagnitude < 49f)
				{
					npcController.OrderToStopSprint();
				}
				base.ai.OrderMoveToDestination();
				return;
			}
			base.ai.StopMoving();
			if (Plugin.IsModLethalPhonesLoaded)
			{
				base.ai.BecomeSwitchboardOperator();
			}
			if (skipTerminalThink)
			{
				skipTerminalThink = false;
			}
			else if (!npcController.Npc.inTerminalMenu)
			{
				if (terminal.terminalInUse || terminal.placeableObject.inUse)
				{
					return;
				}
				overrideCrouch = true;
				if (!npcController.Npc.isCrouching)
				{
					if ((Object)(object)walkieTalkie != (Object)null && !((GrabbableObject)walkieTalkie).isBeingUsed && LethalBotAI.IsItemPowered((GrabbableObject?)(object)walkieTalkie))
					{
						((GrabbableObject)walkieTalkie).ItemInteractLeftRightOnClient(false);
					}
					else
					{
						base.ai.EnterTerminal();
					}
				}
			}
			else if (LethalBotManager.AreWeAtTheCompanyBuilding())
			{
				StopMonitoringCrew();
				StopUsingSignalTranslator();
				StopOrbitLogic();
				if (restockShip == null)
				{
					restockShip = ((MonoBehaviour)base.ai).StartCoroutine(RestockTheShip());
				}
			}
			else if (LethalBotManager.AreWeInOrbit())
			{
				StopMonitoringCrew();
				StopUsingSignalTranslator();
				StopRestockingTheShip();
				if (orbitLogic == null)
				{
					orbitLogic = ((MonoBehaviour)base.ai).StartCoroutine(UseTerminalInOrbit());
				}
			}
			else
			{
				StopRestockingTheShip();
				StopOrbitLogic();
				if (monitorCrew == null)
				{
					monitorCrew = ((MonoBehaviour)base.ai).StartCoroutine(MissionSurveillanceRoutine());
				}
				if (useSignalTranslator == null && (Object)(object)SignalTranslator != (Object)null)
				{
					useSignalTranslator = ((MonoBehaviour)base.ai).StartCoroutine(UseSignalTranslator());
				}
			}
		}

		public override bool? ShouldBotCrouch()
		{
			if (overrideCrouch || npcController.Npc.inTerminalMenu)
			{
				return false;
			}
			return base.ShouldBotCrouch();
		}

		public override void StopAllCoroutines()
		{
			base.StopAllCoroutines();
			StopMonitoringCrew();
			StopUsingSignalTranslator();
			StopRestockingTheShip();
			StopOrbitLogic();
		}

		[IteratorStateMachine(typeof(<MissionSurveillanceRoutine>d__43))]
		private IEnumerator MissionSurveillanceRoutine()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <MissionSurveillanceRoutine>d__43(0)
			{
				<>4__this = this
			};
		}

		[IteratorStateMachine(typeof(<SwitchRadarTarget>d__44))]
		private IEnumerator SwitchRadarTarget(PlayerControllerB? player = null)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <SwitchRadarTarget>d__44(0)
			{
				<>4__this = this,
				player = player
			};
		}

		[IteratorStateMachine(typeof(<UseTerminalAccessibleObjects>d__45))]
		private IEnumerator UseTerminalAccessibleObjects(PlayerControllerB player)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <UseTerminalAccessibleObjects>d__45(0)
			{
				<>4__this = this,
				player = player
			};
		}

		[IteratorStateMachine(typeof(<TryTeleportPlayer>d__46))]
		private IEnumerator TryTeleportPlayer(bool isDeadBody = false, bool skipPostCheck = false)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <TryTeleportPlayer>d__46(0)
			{
				<>4__this = this,
				isDeadBody = isDeadBody,
				skipPostCheck = skipPostCheck
			};
		}

		[IteratorStateMachine(typeof(<HandlePlayerMonitorLogic>d__47))]
		private IEnumerator HandlePlayerMonitorLogic(PlayerControllerB player)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <HandlePlayerMonitorLogic>d__47(0)
			{
				<>4__this = this,
				player = player
			};
		}

		[IteratorStateMachine(typeof(<SendCommandToTerminal>d__48))]
		private IEnumerator SendCommandToTerminal(string command)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <SendCommandToTerminal>d__48(0)
			{
				command = command
			};
		}

		[IteratorStateMachine(typeof(<UseSignalTranslator>d__49))]
		private IEnumerator UseSignalTranslator()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <UseSignalTranslator>d__49(0)
			{
				<>4__this = this
			};
		}

		public void SendMessageUsingSignalTranslator(string message, QueuePriority priority = QueuePriority.Low)
		{
			if (!string.IsNullOrWhiteSpace(message))
			{
				messageQueue.Enqueue(message, priority);
			}
		}

		private string GetNextMessageToSend()
		{
			if (!messageQueue.TryDequeue(out string message) || string.IsNullOrEmpty(message))
			{
				return string.Empty;
			}
			return message;
		}

		private bool HasMessageToSend()
		{
			if (messageQueue.TryPeek(out string message) && !string.IsNullOrEmpty(message))
			{
				return true;
			}
			return messageQueue.Count > 0;
		}

		[IteratorStateMachine(typeof(<RestockTheShip>d__53))]
		private IEnumerator RestockTheShip()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <RestockTheShip>d__53(0)
			{
				<>4__this = this
			};
		}

		[IteratorStateMachine(typeof(<PurchaseItem>d__54))]
		private IEnumerator PurchaseItem(Item item, int numToPurchase = 1, bool overrideEcoLimit = false, int ecoLimit = 0)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <PurchaseItem>d__54(0)
			{
				<>4__this = this,
				item = item,
				numToPurchase = numToPurchase,
				overrideEcoLimit = overrideEcoLimit,
				ecoLimit = ecoLimit
			};
		}

		private int GetPendingOrderCount(Item item, Terminal? ourTerminal = null, ItemDropship? itemDropship = null)
		{
			Item item2 = item;
			if (ourTerminal == null)
			{
				ourTerminal = TerminalManager.Instance.GetTerminal();
			}
			if ((Object)(object)ourTerminal == (Object)null)
			{
				return 0;
			}
			int num = 0;
			int num2 = Array.FindIndex(ourTerminal.buyableItemsList, (Item i) => (Object)(object)i != (Object)null && i.itemName == item2.itemName);
			if (num2 < 0)
			{
				return int.MaxValue;
			}
			foreach (int item3 in ourTerminal.orderedItemsFromTerminal)
			{
				if (item3 == num2)
				{
					num++;
				}
			}
			if ((Object)(object)itemDropship != (Object)null)
			{
				foreach (int item4 in PatchesUtil.itemsToDeliverField.Invoke(itemDropship))
				{
					if (item4 == num2)
					{
						num++;
					}
				}
			}
			return num;
		}

		private int GetNumberOfItemAlreadyOwned(Item item, bool shipOnly = false)
		{
			string itemName = item.itemName;
			int num = 0;
			for (int i = 0; i < LethalBotManager.grabbableObjectsInMap.Count; i++)
			{
				GameObject val = LethalBotManager.grabbableObjectsInMap[i];
				if ((Object)(object)val == (Object)null)
				{
					LethalBotManager.grabbableObjectsInMap.TrimExcess();
					continue;
				}
				GrabbableObject component = val.GetComponent<GrabbableObject>();
				if ((Object)(object)component != (Object)null && component.itemProperties.itemName == itemName && (!shipOnly || component.isInShipRoom))
				{
					num++;
				}
			}
			return num;
		}

		private bool FindItemWithName(string name, out int numFound)
		{
			numFound = 0;
			for (int i = 0; i < LethalBotManager.grabbableObjectsInMap.Count; i++)
			{
				GameObject val = LethalBotManager.grabbableObjectsInMap[i];
				if ((Object)(object)val == (Object)null)
				{
					LethalBotManager.grabbableObjectsInMap.TrimExcess();
					continue;
				}
				GrabbableObject component = val.GetComponent<GrabbableObject>();
				if ((Object)(object)component != (Object)null && component.itemProperties.itemName == name)
				{
					numFound++;
				}
			}
			return numFound > 0;
		}

		[IteratorStateMachine(typeof(<UseTerminalInOrbit>d__58))]
		private IEnumerator UseTerminalInOrbit()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <UseTerminalInOrbit>d__58(0)
			{
				<>4__this = this
			};
		}

		[IteratorStateMachine(typeof(<RouteToMoon>d__59))]
		private IEnumerator RouteToMoon(string moonName)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <RouteToMoon>d__59(0)
			{
				<>4__this = this,
				moonName = moonName
			};
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static bool IsValidRadarTarget([NotNullWhen(true)] PlayerControllerB? player)
		{
			if ((Object)(object)player != (Object)null)
			{
				if (!player.isPlayerControlled)
				{
					return player.isPlayerDead;
				}
				return true;
			}
			return false;
		}

		private static bool IsEnemy(EnemyAI enemy)
		{
			if ((Object)(object)enemy == (Object)null)
			{
				return false;
			}
			switch (enemy.enemyType.enemyName)
			{
			case "Masked":
			case "Spring":
			case "Butler":
			case "Jester":
			case "Crawler":
			case "Bunker Spider":
			case "ImmortalSnail":
			case "ForestGiant":
			case "Butler Bees":
			case "Earth Leviathan":
			case "Red Locust Bees":
			case "Clay Surgeon":
			case "Flowerman":
			case "Bush Wolf":
			case "Centipede":
			case "MouthDog":
			case "Nutcracker":
			case "Blob":
			case "T-rex":
				return true;
			case "Hoarding bug":
				if (enemy.currentBehaviourStateIndex == 2)
				{
					return true;
				}
				return false;
			case "RadMech":
				return true;
			case "Baboon hawk":
				return false;
			case "Maneater":
				if (enemy.currentBehaviourStateIndex > 0)
				{
					return true;
				}
				return false;
			default:
				return false;
			}
		}

		private static string GetEnemyName(EnemyAI enemy)
		{
			string enemyName = enemy.enemyType.enemyName;
			return enemyName switch
			{
				"Clay Surgeon" => "Barber", 
				"Red Locust Bees" => "BEEES", 
				"Centipede" => "Snare Flea", 
				"Flowerman" => "Braken", 
				"Crawler" => "Thumper", 
				"Spring" => "Coil Head", 
				"MouthDog" => "Dog", 
				"RadMech" => "Old Bird", 
				"Bunker Spider" => "Spider", 
				"ForestGiant" => "Giant", 
				_ => enemyName, 
			};
		}

		private void StopMonitoringCrew()
		{
			if (monitorCrew != null)
			{
				((MonoBehaviour)base.ai).StopCoroutine(monitorCrew);
				monitorCrew = null;
			}
		}

		private void StopUsingSignalTranslator()
		{
			if (useSignalTranslator != null)
			{
				((MonoBehaviour)base.ai).StopCoroutine(useSignalTranslator);
				useSignalTranslator = null;
			}
		}

		private void StopRestockingTheShip()
		{
			canCollectPurchasedItems = true;
			if (restockShip != null)
			{
				((MonoBehaviour)base.ai).StopCoroutine(restockShip);
				restockShip = null;
			}
		}

		private void StopOrbitLogic()
		{
			if (orbitLogic != null)
			{
				((MonoBehaviour)base.ai).StopCoroutine(orbitLogic);
				orbitLogic = null;
			}
		}

		private bool ShouldTeleportDeadBody(PlayerControllerB player)
		{
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			DeadBodyInfo deadBody = player.deadBody;
			if ((Object)(object)deadBody != (Object)null && !deadBody.isInShip && !deadBody.grabBodyObject.isHeld && !RescueAndReviveState.CanRevivePlayer(base.ai, player, isMissionController: true) && (!RescueAndReviveState.IsAnyReviveModInstalled() || !IsBodyNearbyLivingPlayers(deadBody, 17f)))
			{
				Bounds bounds = StartOfRound.Instance.shipInnerRoomBounds.bounds;
				if (!((Bounds)(ref bounds)).Contains(((Component)deadBody).transform.position) && !base.ai.CheckProximityForEyelessDogs())
				{
					return true;
				}
			}
			return false;
		}

		private bool IsBodyNearbyLivingPlayers(DeadBodyInfo deadBody, float checkRadius = 10f)
		{
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			PlayerControllerB[] allPlayerScripts = StartOfRound.Instance.allPlayerScripts;
			foreach (PlayerControllerB val in allPlayerScripts)
			{
				if ((Object)(object)val != (Object)null && (Object)(object)val != (Object)(object)npcController.Npc && (Object)(object)val != (Object)(object)deadBody.playerScript && val.isPlayerControlled && !val.isPlayerDead)
				{
					Vector3 val2 = ((Component)deadBody).transform.position - ((Component)val).transform.position;
					if (((Vector3)(ref val2)).sqrMagnitude < checkRadius * checkRadius)
					{
						return true;
					}
				}
			}
			return false;
		}

		private bool IsPlayerInGraveDanger(PlayerControllerB? player)
		{
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)player == (Object)null)
			{
				return false;
			}
			if ((Object)(object)player.inAnimationWithEnemy != (Object)null)
			{
				return true;
			}
			if (!Plugin.Config.AllowMissionControlTeleport.Value)
			{
				return false;
			}
			if (!player.isInElevator && !player.isInHangarShipRoom)
			{
				RoundManager instance = RoundManager.Instance;
				Vector3 position = ((Component)player).transform.position;
				foreach (EnemyAI spawnedEnemy in instance.SpawnedEnemies)
				{
					if (!((Object)(object)spawnedEnemy != (Object)null) || spawnedEnemy.isEnemyDead)
					{
						continue;
					}
					float? fearRangeForEnemies = base.ai.GetFearRangeForEnemies(spawnedEnemy, player);
					if (!fearRangeForEnemies.HasValue)
					{
						continue;
					}
					Vector3 val = ((Component)spawnedEnemy).transform.position - position;
					if (!(((Vector3)(ref val)).sqrMagnitude < fearRangeForEnemies * fearRangeForEnemies))
					{
						continue;
					}
					if (player.criticallyInjured)
					{
						return true;
					}
					LethalBotAI lethalBotAI = LethalBotManager.Instance.GetLethalBotAI(player);
					bool hasRangedWeapon = lethalBotAI?.HasRangedWeapon() ?? false;
					if (LethalBotAI.CanEnemyBeKilled(spawnedEnemy, hasRangedWeapon, (Object)(object)lethalBotAI == (Object)null) && DoesPlayerHaveWeaponInInventory(player))
					{
						return false;
					}
					RadMechAI val2 = (RadMechAI)(object)((spawnedEnemy is RadMechAI) ? spawnedEnemy : null);
					if (val2 != null)
					{
						Threat targetedThreat = val2.targetedThreat;
						object obj;
						if (targetedThreat == null)
						{
							obj = null;
						}
						else
						{
							IVisibleThreat threatScript = targetedThreat.threatScript;
							obj = ((threatScript != null) ? threatScript.GetThreatTransform() : null);
						}
						Transform val3 = (Transform)obj;
						if ((Object)(object)((Component)player).transform == (Object)(object)val3)
						{
							return true;
						}
						continue;
					}
					BaboonBirdAI val4 = (BaboonBirdAI)(object)((spawnedEnemy is BaboonBirdAI) ? spawnedEnemy : null);
					if (val4 != null)
					{
						Threat focusedThreat = val4.focusedThreat;
						object obj2;
						if (focusedThreat == null)
						{
							obj2 = null;
						}
						else
						{
							IVisibleThreat threatScript2 = focusedThreat.threatScript;
							obj2 = ((threatScript2 != null) ? threatScript2.GetThreatTransform() : null);
						}
						Transform val5 = (Transform)obj2;
						if ((Object)(object)((Component)player).transform == (Object)(object)val5)
						{
							return true;
						}
					}
					else
					{
						if (spawnedEnemy is JesterAI)
						{
							return true;
						}
						if ((Object)(object)spawnedEnemy.targetPlayer == (Object)(object)player)
						{
							return true;
						}
					}
				}
			}
			return false;
		}

		private static bool DoesPlayerHaveWeaponInInventory(PlayerControllerB? player)
		{
			if ((Object)(object)player == (Object)null)
			{
				return false;
			}
			bool flag = LethalBotManager.Instance.IsPlayerLethalBot(player);
			GrabbableObject itemOnlySlot = player.ItemOnlySlot;
			if (LethalBotAI.IsItemWeapon(itemOnlySlot) || (!flag && (Object)(object)itemOnlySlot != (Object)null && itemOnlySlot.itemProperties.isDefensiveWeapon))
			{
				return true;
			}
			GrabbableObject[] itemSlots = player.ItemSlots;
			foreach (GrabbableObject val in itemSlots)
			{
				if (LethalBotAI.IsItemWeapon(val) || (!flag && (Object)(object)val != (Object)null && val.itemProperties.isDefensiveWeapon))
				{
					return true;
				}
			}
			return false;
		}

		private static TerminalAccessibleObject[] FindTerminalAccessibleObjectsToUse(PlayerControllerB? player)
		{
			//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_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_013a: Unknown result type (might be due to invalid IL or missing references)
			//IL_013f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0140: Unknown result type (might be due to invalid IL or missing references)
			//IL_0145: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0234: Unknown result type (might be due to invalid IL or missing references)
			//IL_0239: Unknown result type (might be due to invalid IL or missing references)
			//IL_0243: Unknown result type (might be due to invalid IL or missing references)
			//IL_0248: Unknown result type (might be due to invalid IL or missing references)
			//IL_0253: Unknown result type (might be due to invalid IL or missing references)
			//IL_026f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0274: Unknown result type (might be due to invalid IL or missing references)
			//IL_0276: Unknown result type (might be due to invalid IL or missing references)
			//IL_0278: Unknown result type (might be due to invalid IL or missing references)
			//IL_0293: Unknown result type (might be due to invalid IL or missing references)
			//IL_0298: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)player == (Object)null)
			{
				return (TerminalAccessibleObject[])(object)new TerminalAccessibleObject[0];
			}
			List<TerminalAccessibleObject> list = new List<TerminalAccessibleObject>();
			Vector3 position = ((Component)player).transform.position;
			if ((Object)(object)player.redirectToEnemy != (Object)null)
			{
				position = ((Component)player.redirectToEnemy).transform.position;
			}
			else if ((Object)(object)player.deadBody != (Object)null)
			{
				position = ((Component)player.deadBody).transform.position;
			}
			Vector3 val;
			foreach (KeyValuePair<Turret, TerminalAccessibleObject> turret in turrets)
			{
				Turret key = turret.Key;
				if (!((Object)(object)key != (Object)null))
				{
					continue;
				}
				if (!((Object)(object)key.targetPlayerWithRotation == (Object)(object)player))
				{
					val = ((Component)key).transform.position - position;
					if (!(((Vector3)(ref val)).sqrMagnitude < 1600f))
					{
						continue;
					}
				}
				TerminalAccessibleObject value = turret.Value;
				if ((Object)(object)value != (Object)null && !inCooldown.Invoke(value))
				{
					list.Add(value);
				}
			}
			foreach (KeyValuePair<Landmine, TerminalAccessibleObject> landmine in landmines)
			{
				Landmine key2 = landmine.Key;
				if (!((Object)(object)key2 != (Object)null) || key2.hasExploded)
				{
					continue;
				}
				val = ((Component)key2).transform.position - position;
				if (((Vector3)(ref val)).sqrMagnitude < 1600f)
				{
					TerminalAccessibleObject value2 = landmine.Value;
					if ((Object)(object)value2 != (Object)null && !inCooldown.Invoke(value2))
					{
						list.Add(value2);
					}
				}
			}
			foreach (KeyValuePair<SpikeRoofTrap, TerminalAccessibleObject> spikeRoofTrap in spikeRoofTraps)
			{
				SpikeRoofTrap key3 = spikeRoofTrap.Key;
				if (!((Object)(object)key3 != (Object)null))
				{
					continue;
				}
				val = ((Component)key3.spikeTrapAudio).transform.position - position;
				if (((Vector3)(ref val)).sqrMagnitude < 1600f)
				{
					TerminalAccessibleObject value3 = spikeRoofTrap.Value;
					if ((Object)(object)value3 != (Object)null && !inCooldown.Invoke(value3))
					{
						list.Add(value3);
					}
				}
			}
			Ray val2 = default(Ray);
			((Ray)(ref val2))..ctor(((Component)player).transform.position + Vector3.up * 2.3f, ((Component)player).transform.forward);
			float num = player.grabDistance * 2f;
			LayerMask val3 = LayerMask.op_Implicit(1342179585);
			RaycastHit[] array = Physics.RaycastAll(val2, num, LayerMask.op_Implicit(val3));
			RaycastHit[] array2 = array;
			for (int i = 0; i < array2.Length; i++)
			{
				RaycastHit val4 = array2[i];
				TerminalAccessibleObject component = ((Component)((RaycastHit)(ref val4)).collider).gameObject.GetComponent<TerminalAccessibleObject>();
				if ((Object)(object)component != (Object)null && component.isBigDoor && !list.Contains(component) && !inCooldown.Invoke(component) && !isDoorOpen.Invoke(component))
				{
					list.Add(component);
				}
			}
			return list.ToArray();
		}

		private static string GetCurrentTime(float timeNormalized, float numberOfHours, bool createNewLine = true)
		{
			int num = (int)(timeNormalized * (60f * numberOfHours)) + 360;
			int num2 = (int)Mathf.Floor((float)(num / 60));
			string text = (createNewLine ? "\n" : " ");
			string text2 = text + "AM";
			if (num2 >= 24)
			{
				return "12:00" + text + "AM";
			}
			text2 = ((num2 >= 12) ? (text + "PM") : (text + "AM"));
			if (num2 > 12)
			{
				num2 %= 12;
			}
			int num3 = num % 60;
			return $"{num2:00}:{num3:00}".TrimStart('0') + text2;
		}

		private void FindWalkieTalkie()
		{
			walkieTalkie = null;
			if (base.ai.HasGrabbableObjectInInventory((Func<GrabbableObject, bool>)FindWalkieHelper, out int objectSlot))
			{
				ref WalkieTalkie? reference = ref walkieTalkie;
				GrabbableObject? itemAtSlot = base.ai.GetItemAtSlot(objectSlot);
				reference = (WalkieTalkie?)(object)((itemAtSlot is WalkieTalkie) ? itemAtSlot : null);
				if ((Object)(object)walkieTalkie != (Object)null)
				{
					return;
				}
			}
			ref WalkieTalkie? reference2 = ref walkieTalkie;
			GrabbableObject? obj = base.ai.FindItemOnShip((GrabbableObject foundItem) => foundItem is WalkieTalkie);
			reference2 = (WalkieTalkie?)(object)((obj is WalkieTalkie) ? obj : null);
		}

		private bool FindWalkieHelper(GrabbableObject item)
		{
			if ((Object)(object)item != (Object)null)
			{
				return item is WalkieTalkie;
			}
			return false;
		}

		private void FindWeapon()
		{
			weapon = null;
			if (base.ai.HasGrabbableObjectInInventory((Func<GrabbableObject, bool>)FindWeaponHelper, out int objectSlot))
			{
				weapon = base.ai.GetItemAtSlot(objectSlot);
				if ((Object)(object)weapon != (Object)null)
				{
					return;
				}
			}
			weapon = base.ai.FindItemOnShip((GrabbableObject foundItem) => base.ai.HasAmmoForWeapon(foundItem));
		}

		private bool FindWeaponHelper(GrabbableObject item)
		{
			if ((Object)(object)item != (Object)null)
			{
				return base.ai.HasAmmoForWeapon(item);
			}
			return false;
		}

		private void SetupTerminalAccessibleObjects()
		{
			turrets.Clear();
			landmines.Clear();
			spikeRoofTraps.Clear();
			Turret[] array = Object.FindObjectsOfType<Turret>();
			Landmine[] array2 = Object.FindObjectsOfType<Landmine>();
			SpikeRoofTrap[] array3 = Object.FindObjectsOfType<SpikeRoofTrap>();
			Turret[] array4 = array;
			foreach (Turret val in array4)
			{
				if (!((Object)(object)val == (Object)null))
				{
					TerminalAccessibleObject component = ((Component)val).GetComponent<TerminalAccessibleObject>();
					if ((Object)(object)component == (Object)null)
					{
						Plugin.LogWarning($"Turret object {val}, had no TerminalAccessableObject!? This should not happen!");
					}
					else if (!turrets.TryAdd(val, component))
					{
						Plugin.LogWarning($"Turret object {val} was already added to turrets table, skipping!");
					}
				}
			}
			Landmine[] array5 = array2;
			foreach (Landmine val2 in array5)
			{
				if (!((Object)(object)val2 == (Object)null))
				{
					TerminalAccessibleObject component2 = ((Component)val2).GetComponent<TerminalAccessibleObject>();
					if ((Object)(object)component2 == (Object)null)
					{
						Plugin.LogWarning($"Landmine object {val2}, had no TerminalAccessableObject!? This should not happen!");
					}
					else if (!landmines.TryAdd(val2, component2))
					{
						Plugin.LogWarning($"Landmine object {val2} was already added to landmines table, skipping!");
					}
				}
			}
			SpikeRoofTrap[] array6 = array3;
			foreach (SpikeRoofTrap val3 in array6)
			{
				if (!((Object)(object)val3 == (Object)null))
				{
					Transform transform = ((Component)val3).transform;
					object obj;
					if (transform == null)
					{
						obj = null;
					}
					else
					{
						Transform root = transform.root;
						obj = ((root != null) ? ((Component)root).GetComponentInChildren<TerminalAccessibleObject>() : null);
					}
					TerminalAccessibleObject val4 = (TerminalAccessibleObject)obj;
					if ((Object)(object)val4 == (Object)null)
					{
						Plugin.LogWarning($"Spike Roof Trap object {val3}, had no TerminalAccessableObject!? This should not happen!");
					}
					else if (!spikeRoofTraps.TryAdd(val3, val4))
					{
						Plugin.LogWarning($"Spike Roof Trap object {val3} was already added to Spike Roof Traps table, skipping!");
					}
				}
			}
		}

		private EnemyAI? CheckForInvadingEnemy(bool onlyKillable = true, bool checkOutsideShip = false)
		{
			//IL_003a: 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_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			RoundManager instance = RoundManager.Instance;
			Transform transform = ((Component)npcController.Npc.gameplayCamera).transform;
			Bounds val = (checkOutsideShip ? StartOfRound.Instance.shipBounds.bounds : StartOfRound.Instance.shipInnerRoomBounds.bounds);
			EnemyAI result = null;
			float num = float.MaxValue;
			foreach (EnemyAI spawnedEnemy in instance.SpawnedEnemies)
			{
				if (!spawnedEnemy.isEnemyDead && (!onlyKillable || base.ai.CanEnemyBeKilled(spawnedEnemy, isMissionController: true)) && (spawnedEnemy.isInsidePlayerShip || ((Bounds)(ref val)).Contains(((Component)spawnedEnemy).transform.position)) && base.ai.GetFearRangeForEnemies(spawnedEnemy).HasValue)
				{
					MaskedPlayerEnemy val2 = (MaskedPlayerEnemy)(object)((spawnedEnemy is MaskedPlayerEnemy) ? spawnedEnemy : null);
					if (val2 != null)
					{
						base.ai.DictKnownMasked[val2] = true;
					}
					Vector3 position = ((Component)spawnedEnemy).transform.position;
					Vector3 val3 = position - transform.position;
					float sqrMagnitude = ((Vector3)(ref val3)).sqrMagnitude;
					if (sqrMagnitude < num)
					{
						num = sqrMagnitude;
						result = spawnedEnemy;
					}
				}
			}
			return result;
		}

		public override bool CheckAllowsTerminalUse()
		{
			return true;
		}

		public override void TryPlayCurrentStateVoiceAudio()
		{
			if ((Object)(object)walkieTalkie != (Object)null || Plugin.IsModLethalPhonesLoaded)
			{
				base.ai.LethalBotIdentity.Voice.TryPlayVoiceAudio(new PlayVoiceParameters
				{
					VoiceState = EnumVoicesState.Chilling,
					CanTalkIfOtherLethalBotTalk = true,
					WaitForCooldown = true,
					CutCurrentVoiceStateToTalk = false,
					CanRepeatVoiceState = true,
					ShouldSync = true,
					IsLethalBotInside = npcController.Npc.isInsideFactory,
					AllowSwearing = Plugin.Config.AllowSwearing.Value
				});
			}
		}

		public new static void RegisterChatCommands()
		{
			ChatCommandsManager.RegisterIgnoreDefaultForState<MissionControlState>();
			ChatCommandsManager.RegisterCommandForState<MissionControlState>(new ChatCommand("start the ship", delegate(AIState state, LethalBotAI lethalBotAI, PlayerControllerB playerWhoSentMessage, string message, bool isVoice)
			{
				if ((Object)(object)playerWhoSentMessage == (Object)null)
				{
					return true;
				}
				MissionControlState missionControlState6 = (MissionControlState)state;
				PlayerControllerB hostPlayerScript = LethalBotManager.HostPlayerScript;
				if ((Object)(object)hostPlayerScript == (Object)null || (Object)(object)hostPlayerScript == (Object)(object)playerWhoSentMessage || hostPlayerScript.isPlayerDead || !Plugin.Config.StartShipChatCommandProtection.Value)
				{
					if (LethalBotManager.AreWeAtTheCompanyBuilding())
					{
						lethalBotAI.SendChatMessage($"Affirmative, I will start the ship in {5f} seconds and once everyone is onboard.");
					}
					else
					{
						lethalBotAI.SendChatMessage($"Affirmative, I will start the ship in {5f} seconds.");
					}
					missionControlState6.playerRequestLeave = true;
				}
				else
				{
					lethalBotAI.SendChatMessage("Sorry " + playerWhoSentMessage.playerUsername + ", but only the captain can tell me to start the ship!");
				}
				return true;
			}));
			ChatCommandsManager.RegisterCommandForState<MissionControlState>(new ChatCommand("request monitoring", delegate(AIState state, LethalBotAI lethalBotAI, PlayerControllerB playerWhoSentMessage, string message, bool isVoice)
			{
				MissionControlState missionControlState5 = (MissionControlState)state;
				lethalBotAI.SendChatMessage("Roger, I will only monitor you, " + playerWhoSentMessage.playerUsername + ".");
				missionControlState5.monitoredPlayer = playerWhoSentMessage;
				return true;
			}));
			ChatCommandsManager.RegisterCommandForState<MissionControlState>(new ChatCommand("clear monitoring", delegate(AIState state, LethalBotAI lethalBotAI, PlayerControllerB playerWhoSentMessage, string message, bool isVoice)
			{
				MissionControlState missionControlState4 = (MissionControlState)state;
				if ((Object)(object)missionControlState4.monitoredPlayer != (Object)(object)playerWhoSentMessage)
				{
					return true;
				}
				lethalBotAI.SendChatMessage("Understood, I will resume monitoring all crew members.");
				missionControlState4.monitoredPlayer = null;
				return true;
			}));
			ChatCommandsManager.RegisterCommandForState<MissionControlState>(new ChatCommand("request teleport", delegate(AIState state, LethalBotAI lethalBotAI, PlayerControllerB playerWhoSentMessage, string message, bool isVoice)
			{
				if ((Object)(object)ShipTeleporter == (Object)null)
				{
					lethalBotAI.SendChatMessage("What do you mean, \"TELEPORT ME\"! We don't own a teleporter!");
					return true;
				}
				MissionControlState missionControlState3 = (MissionControlState)state;
				if (!missionControlState3.playersRequstedTeleport.Contains(playerWhoSentMessage))
				{
					lethalBotAI.SendChatMessage("Hold on, I will teleport you back to the ship as soon as possible.");
					missionControlState3.playersRequstedTeleport.Enqueue(playerWhoSentMessage);
				}
				return true;
			}));
			ChatCommandsManager.RegisterCommandForState<MissionControlState>(new ChatCommand("hop off the terminal", delegate(AIState state, LethalBotAI lethalBotAI, PlayerControllerB playerWhoSentMessage, string message, bool isVoice)
			{
				MissionControlState missionControlState2 = (MissionControlState)state;
				if (!missionControlState2.playerRequestedTerminal)
				{
					lethalBotAI.SendChatMessage("Understood, I am leaving the terminal now.");
				}
				missionControlState2.playerRequestedTerminal = true;
				missionControlState2.waitForTerminalTime = 0f;
				return true;
			}));
			ChatCommandsManager.RegisterCommandForState<MissionControlState>(new ChatCommand("transmit", delegate(AIState state, LethalBotAI lethalBotAI, PlayerControllerB playerWhoSentMessage, string message, bool isVoice)
			{
				MissionControlState missionControlState = (MissionControlState)state;
				int startIndex = message.IndexOf("transmit") + Const.TRANSMIT_KEYWORD_LENGTH;
				string text = message.Substring(startIndex).Trim();
				lethalBotAI.SendChatMessage("Alright, I will relay, " + text + " to the rest of the crew.");
				missionControlState.SendMessageUsingSignalTranslator(text, QueuePriority.High);
				return true;
			}));
		}

		public new static void RegisterSignalTranslatorCommands()
		{
			SignalTranslatorCommandsManager.RegisterIgnoreDefaultForState<MissionControlState>();
		}

		public override void UseLethalPhones()
		{
			SwitchboardPhone val = PhoneNetworkHandler.Instance?.switchboard;
			if ((Object)(object)val != (Object)null)
			{
				PlayerControllerB switchboardOperator = val.switchboardOperator;
				if ((Object)(object)switchboardOperator != (Object)null && (Object)(object)switchboardOperator == (Object)(object)npcController.Npc)
				{
					PlayerPhone ourPlayerPhone = base.ai.GetOurPlayerPhone();
					if ((Object)(object)ourPlayerPhone != (Object)null && (((PhoneBehavior)ourPlayerPhone).IsBusy() || base.ai.IsPhoneEquipped()))
					{
						base.ai.HangupPhone();
						return;
					}
					NetworkVariable<short> val2 = (NetworkVariable<short>)PhoneBehaviorPatch.incomingCall.GetValue(val);
					if (val2.Value == -1)
					{
						return;
					}
					Transform transform = ((Component)val).transform;
					object obj;
					if (transform == null)
					{
						obj = null;
					}
					else
					{
						Transform obj2 = transform.Find("GreenButtonCube");
						obj = ((obj2 != null) ? ((Component)obj2).GetComponent<InteractTrigger>() : null);
					}
					InteractTrigger val3 = (InteractTrigger)obj;
					if ((Object)(object)val3 != (Object)null)
					{
						if (!GetOffTerminal())
						{
							try
							{
								val3.Interact(npcController.Npc.thisPlayerBody);
								return;
							}
							catch (Exception ex)
							{
								Plugin.LogError("Error occurred when bot " + npcController.Npc.playerUsername + " attempted to press accept call button on the SwitchBoard!");
								Plugin.LogError("Exception: " + ex.Message);
								val.CallButtonPressedServerRpc();
								return;
							}
						}
						skipTerminalThink = true;
					}
					else
					{
						val.CallButtonPressedServerRpc();
					}
					return;
				}
			}
			base.UseLethalPhones();
		}

		private bool GetOffTerminal()
		{
			if (npcController.Npc.inTerminalMenu)
			{
				StopAllCoroutines();
				base.ai.LeaveTerminal();
				return true;
			}
			return false;
		}

		protected override bool FindObject(GrabbableObject item)
		{
			if ((Object)(object)item == (Object)(object)walkieTalkie || (Object)(object)item == (Object)(object)weapon)
			{
				return false;
			}
			return base.FindObject(item);
		}
	}
	public class PanikState : AIState
	{
		private sealed class NodeSafety : IComparable<NodeSafety>, IEquatable<NodeSafety>
		{
			public GameObject node;

			public float fearRange;

			public bool isPathOutOfSight;

			public bool isNodeOutOfSight;

			public float minPathDistanceToEnemy;

			public float enemyPathDistance;

			public float botPathDistance;

			public NodeSafety(GameObject node, float fearRange, bool isPathOutOfSight, bool isNodeOutOfSight)
			{
				this.node = node ?? throw new ArgumentNullException("node");
				this.fearRange = fearRange;
				this.isPathOutOfSight = isPathOutOfSight;
				this.isNodeOutOfSight = isNodeOutOfSight;
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			public Vector3 GetNodePosition()
			{
				//IL_000b: Unknown result type (might be due to invalid IL or missing references)
				return node.transform.position;
			}

			public float GetSafetyScore()
			{
				float num = 0f;
				if (minPathDistanceToEnemy < fearRange)
				{
					num -= 100f;
					num += Mathf.Min(enemyPathDistance - fearRange, 0f) * 1.2f;
				}
				else
				{
					num += minPathDistanceToEnemy * 2.5f;
					num += (enemyPathDistance - fearRange) * 1.2f;
				}
				if (isPathOutOfSight)
				{
					num += 15f;
				}
				if (isNodeOutOfSight)
				{
					num += 10f;
				}
				return num - botPathDistance * 0.6f;
			}

			public override string ToString()
			{
				return $"GameObject: {node}, IsPathOutOfSight: {isPathOutOfSight}, IsNodeOutOfSight: {isNodeOutOfSight}, MinPathDistanceToEnemy: {minPathDistanceToEnemy}, EnemyPathDistance: {enemyPathDistance}, BotPathDistance: {botPathDistance}";
			}

			public int CompareTo(NodeSafety? other)
			{
				if ((object)other == null)
				{
					return 1;
				}
				float safetyScore = GetSafetyScore();
				float safetyScore2 = other.GetSafetyScore();
				if (Mathf.Approximately(safetyScore, safetyScore2))
				{
					return 0;
				}
				if (!(safetyScore > safetyScore2))
				{
					return -1;
				}
				return 1;
			}

			public bool Equals(NodeSafety? other)
			{
				if ((object)other == null)
				{
					return false;
				}
				if ((Object)(object)node == (Object)(object)other.node && fearRange == other.fearRange && isPathOutOfSight == other.isPathOutOfSight && isNodeOutOfSight == other.isNodeOutOfSight && minPathDistanceToEnemy == other.minPathDistanceToEnemy && enemyPathDistance == other.enemyPathDistance)
				{
					return botPathDistance == other.botPathDistance;
				}
				return false;
			}

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

			public override int GetHashCode()
			{
				return HashCode.Combine<GameObject, float, bool, bool, float, float, float>(node, fearRange, isPathOutOfSight, isNodeOutOfSight, minPathDistanceToEnemy, enemyPathDistance, botPathDistance);
			}

			public static bool operator <(NodeSafety? left, NodeSafety? right)
			{
				if ((object)left == null)
				{
					return (object)right != null;
				}
				return left.CompareTo(right) < 0;
			}

			public static bool operator >(NodeSafety? left, NodeSafety? right)
			{
				if ((object)left == null)
				{
					return false;
				}
				return left.CompareTo(right) > 0;
			}

			public static bool operator <=(NodeSafety? left, NodeSafety? right)
			{
				if ((object)left == null)
				{
					return (object)right == null;
				}
				return left.CompareTo(right) <= 0;
			}

			public static bool operator >=(NodeSafety? left, NodeSafety? right)
			{
				if ((object)left == null)
				{
					return (object)right == null;
				}
				return left.CompareTo(right) >= 0;
			}

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

			public static bool operator !=(NodeSafety? left, NodeSafety? right)
			{
				return !(left == right);
			}
		}

		[CompilerGenerated]
		private sealed class <ChooseFleeingNodeFromPosition>d__25 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public PanikState <>4__this;

			public EnemyAI enemy;

			public float fearRange;

			private Vector3 <ourPos>5__2;

			private Transform <enemyTransform>5__3;

			private Vector3 <enemyPos>5__4;

			private Vector3 <viewPos>5__5;

			private float <headOffset>5__6;

			private int <maxAsync>5__7;

			private NodeSafety <bestNode>5__8;

			private int <i>5__9;

			private GameObject <node>5__10;

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

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

			[DebuggerHidden]
			public <ChooseFleeingNodeFromPosition>d__25(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<enemyTransform>5__3 = null;
				<bestNode>5__8 = null;
				<node>5__10 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_005e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0063: Unknown result type (might be due to invalid IL or missing references)
				//IL_0080: Unknown result type (might be due to invalid IL or missing references)
				//IL_0085: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
				//IL_009f: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
				//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
				//IL_010b: Unknown result type (might be due to invalid IL or missing references)
				//IL_01ca: Unknown result type (might be due to invalid IL or missing references)
				//IL_01cf: Unknown result type (might be due to invalid IL or missing references)
				//IL_0217: Unknown result type (might be due to invalid IL or missing references)
				//IL_01e5: Unknown result type (might be due to invalid IL or missing references)
				//IL_0475: Unknown result type (might be due to invalid IL or missing references)
				//IL_047f: Expected O, but got Unknown
				//IL_03d8: Unknown result type (might be due to invalid IL or missing references)
				//IL_03e3: Unknown result type (might be due to invalid IL or missing references)
				//IL_0413: Unknown result type (might be due to invalid IL or missing references)
				//IL_0432: Unknown result type (might be due to invalid IL or missing references)
				//IL_026e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0273: Unknown result type (might be due to invalid IL or missing references)
				//IL_027b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0280: Unknown result type (might be due to invalid IL or missing references)
				//IL_0282: Unknown result type (might be due to invalid IL or missing references)
				//IL_0284: Unknown result type (might be due to invalid IL or missing references)
				//IL_0287: Unknown result type (might be due to invalid IL or missing references)
				//IL_028c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0291: Unknown result type (might be due to invalid IL or missing references)
				//IL_0293: Unknown result type (might be due to invalid IL or missing references)
				//IL_0296: Unknown result type (might be due to invalid IL or missing references)
				//IL_02d7: Unknown result type (might be due to invalid IL or missing references)
				//IL_02d9: Unknown result type (might be due to invalid IL or missing references)
				//IL_02e4: Unknown result type (might be due to invalid IL or missing references)
				//IL_02e9: Unknown result type (might be due to invalid IL or missing references)
				//IL_02ee: Unknown result type (might be due to invalid IL or missing references)
				//IL_02f1: Unknown result type (might be due to invalid IL or missing references)
				//IL_02f6: Unknown result type (might be due to invalid IL or missing references)
				//IL_02a4: Unknown result type (might be due to invalid IL or missing references)
				//IL_02a7: Unknown result type (might be due to invalid IL or missing references)
				//IL_02ac: Unknown result type (might be due to invalid IL or missing references)
				//IL_02b1: Unknown result type (might be due to invalid IL or missing references)
				int num = <>1__state;
				PanikState panikState = <>4__this;
				Vector3 val;
				switch (num)
				{
				default:
					return false;
				case 0:
				{
					<>1__state = -1;
					Plugin.LogDebug("Start panik coroutine for " + panikState.npcController.Npc.playerUsername + "!");
					<ourPos>5__2 = ((Component)panikState.npcController.Npc).transform.position;
					<enemyTransform>5__3 = ((Component)enemy).transform;
					<enemyPos>5__4 = <enemyTransform>5__3.position;
					<viewPos>5__5 = (((Object)(object)enemy.eye != (Object)null) ? enemy.eye.position : <enemyPos>5__4);
					<viewPos>5__5 += Vector3.up * 0.2f;
					val = <enemyPos>5__4 - <ourPos>5__2;
					float sqrMagnitude = ((Vector3)(ref val)).sqrMagnitude;
					<headOffset>5__6 = ((Component)panikState.npcController.Npc.gameplayCamera).transform.position.y - <ourPos>5__2.y;
					if (sqrMagnitude < 256f)
					{
						<maxAsync>5__7 = 25;
					}
					else if (sqrMagnitude < 1600f)
					{
						<maxAsync>5__7 = 15;
					}
					else
					{
						<maxAsync>5__7 = 5;
					}
					<bestNode>5__8 = null;
					<i>5__9 = 0;
					goto IL_0350;
				}
				case 1:
					<>1__state = -1;
					goto IL_01a2;
				case 2:
					{
						<>1__state = -1;
						if ((Object)(object)panikState.CurrentEnemy != (Object)null)
						{
							panikState.RetreatPos = null;
							panikState.panikCoroutine = null;
						}
						return false;
					}
					IL_0350:
					if (<i>5__9 < ((EnemyAI)panikState.ai).allAINodes.Length)
					{
						<node>5__10 = ((EnemyAI)panikState.ai).allAINodes[<i>5__9];
						if (<i>5__9 % <maxAsync>5__7 == 0)
						{
							<>2__current = null;
							<>1__state = 1;
							return true;
						}
						goto IL_01a2;
					}
					if (<bestNode>5__8 != null)
					{
						Plugin.LogDebug($"Found a node to run to: {<bestNode>5__8} for {panikState.npcController.Npc.playerUsername}!");
						Plugin.LogDebug($"Distance to node: {<bestNode>5__8.botPathDistance} for {panikState.npcController.Npc.playerUsername}!");
						Plugin.LogDebug($"Distance to enemy: {Vector3.Distance(<bestNode>5__8.GetNodePosition(), <enemyTransform>5__3.position)} for {panikState.npcController.Npc.playerUsername}!");
						panikState.RetreatPos = <bestNode>5__8.GetNodePosition();
						panikState.ai.SetDestinationToPositionLethalBotAI(panikState.RetreatPos.Value);
						panikState.ai.OrderMoveToDestination();
						panikState.panikCoroutine = null;
						return false;
					}
					Plugin.LogDebug("Failed to find a node to run to for " + panikState.npcController.Npc.playerUsername + "!");
					<>2__current = (object)new WaitForEndOfFrame();
					<>1__state = 2;
					return true;
					IL_033e:
					<i>5__9++;
					goto IL_0350;
					IL_01a2:
					if (!((Object)(object)<node>5__10 == (Object)null))
					{
						NodeSafety nodeSafety = new NodeSafety(<node>5__10, fearRange, isPathOutOfSight: true, isNodeOutOfSight: true);
						Vector3 nodePosition = nodeSafety.GetNodePosition();
						if ((Object)(object)enemy != (Object)null)
						{
							if (enemy.PathIsIntersectedByLineOfSight(nodePosition, true, false, false))
							{
								nodeSafety.enemyPathDistance = 99999f;
							}
							else
							{
								nodeSafety.enemyPathDistance = enemy.pathDistance;
							}
						}
						if (panikState.ai.PathIsIntersectedByLineOfSight(nodePosition, out var isPathVaild, calculatePathDistance: true, avoidLineOfSight: true, enemy))
						{
							nodeSafety.isPathOutOfSight = false;
							if (!isPathVaild)
							{
								goto IL_033e;
							}
						}
						nodeSafety.botPathDistance = ((EnemyAI)panikState.ai).pathDistance;
						Vector3[] corners = ((EnemyAI)panikState.ai).path1.corners;
						float num2 = float.MaxValue;
						for (int i = 1; i < corners.Length; i++)
						{
							Vector3 vLineB = corners[i];
							Vector3 vLineA = corners[i - 1];
							Vector3 closestPointOnLineSegment = LethalBotAI.GetClosestPointOnLineSegment(vLineA, vLineB, <enemyPos>5__4);
							if (!(closestPointOnLineSegment == <ourPos>5__2))
							{
								float num3 = num2;
								val = closestPointOnLineSegment - <enemyPos>5__4;
								num2 = Mathf.Min(num3, ((Vector3)(ref val)).sqrMagnitude);
							}
						}
						nodeSafety.minPathDistanceToEnemy = num2;
						Vector3 val2 = nodePosition + Vector3.up * <headOffset>5__6;
						if (!Physics.Linecast(<viewPos>5__5, val2, StartOfRound.Instance.collidersAndRoomMaskAndDefault, (QueryTriggerInteraction)1))
						{
							nodeSafety.isNodeOutOfSight = false;
						}
						if (<bestNode>5__8 == null || nodeSafety > <bestNode>5__8)
						{
							<bestNode>5__8 = nodeSafety;
						}
						<node>5__10 = null;
					}
					goto IL_033e;
				}
			}

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

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

		private CountdownTimer updateRetreatPosTimer = new CountdownTimer();

		private float findEntranceTimer;

		private float calmDownTimer;

		private float breakLOSTimer;

		private const float declareJesterCooldownTime = 30f;

		private float lastDeclaredJesterTimer;

		private bool wasFleeingJester;

		private Vector3? _retreatPos;

		private Vector3? RetreatPos
		{
			get
			{
				return _retreatPos;
			}
			set
			{
				//IL_0013: Unknown result type (might be due to invalid IL or missing references)
				//IL_001d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0028: Unknown result type (might be due to invalid IL or missing references)
				Vector3? val = value;
				if (val.HasValue)
				{
					_retreatPos = RoundManager.Instance.GetNavMeshPosition(val.Value, RoundManager.Instance.navHit, 2.7f, -1);
				}
				else
				{
					_retreatPos = null;
				}
				updateRetreatPosTimer.Start(5f);
			}
		}

		public PanikState(AIState oldState, EnemyAI enemyAI)
			: base(oldState)
		{
			base.CurrentState = EnumAIStates.Panik;
			Plugin.LogDebug(npcController.Npc.playerUsername + " enemy seen " + enemyAI.enemyType.enemyName);
			base.CurrentEnemy = enemyAI;
		}

		public override void OnEnterState()
		{
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_011a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Unknown result type (might be due to invalid IL or missing references)
			//IL_0137: Unknown result type (might be due to invalid IL or missing references)
			//IL_0148: Unknown result type (might be due to invalid IL or missing references)
			//IL_0152: Unknown result type (might be due to invalid IL or missing references)
			//IL_015c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0186: Unknown result type (might be due to invalid IL or missing references)
			//IL_0178: Unknown result type (might be due to invalid IL or missing references)
			//IL_018b: Unknown result type (might be due to invalid IL or missing references)
			//IL_018d: Unknown result type (might be due to invalid IL or missing references)
			if (!hasBeenStarted)
			{
				if ((Object)(object)base.CurrentEnemy == (Object)null || base.CurrentEnemy.isEnemyDead)
				{
					Plugin.LogWarning("PanikState: CurrentEnemy is null or dead, cannot start panik state!");
					ChangeBackToPreviousState();
					return;
				}
				float? fearRangeForEnemies = base.ai.GetFearRangeForEnemies(base.CurrentEnemy);
				if (!fearRangeForEnemies.HasValue)
				{
					ChangeBackToPreviousState();
					return;
				}
				if (base.ai.HasCombatWeapon() && base.ai.CanEnemyBeKilled(base.CurrentEnemy, (Object)(object)LethalBotManager.Instance.MissionControlPlayer == (Object)(object)npcController.Npc))
				{
					base.ai.State = new FightEnemyState(this, base.CurrentEnemy, previousAIState);
					return;
				}
				targetEntrance = FindClosestEntrance();
				Ray val = default(Ray);
				((Ray)(ref val))..ctor(((Component)npcController.Npc).transform.position, ((Component)npcController.Npc).transform.position + Vector3.up * 0.2f - ((Component)base.CurrentEnemy).transform.position + Vector3.up * 0.2f);
				((Ray)(ref val)).direction = new Vector3(((Ray)(ref val)).direction.x, 0f, ((Ray)(ref val)).direction.z);
				RaycastHit val2 = default(RaycastHit);
				Vector3 value = ((!Physics.Raycast(val, ref val2, 20f, StartOfRound.Instance.collidersAndRoomMaskAndDefault, (QueryTriggerInteraction)1)) ? ((Ray)(ref val)).GetPoint(20f) : ((RaycastHit)(ref val2)).point);
				RetreatPos = value;
				StartPanikCoroutine(base.CurrentEnemy, fearRangeForEnemies.Value);
				if (base.CurrentEnemy is JesterAI)
				{
					wasFleeingJester = true;
					if (Time.timeSinceLevelLoad - lastDeclaredJesterTimer > 30f)
					{
						lastDeclaredJesterTimer = Time.timeSinceLevelLoad;
						base.ai.SendChatMessage("JESTER!!! RUN!!!", bypassConfig: true);
					}
				}
			}
			base.OnEnterState();
		}

		public override void DoAI()
		{
			//IL_0288: Unknown result type (might be due to invalid IL or missing references)
			//IL_0298: Unknown result type (might be due to invalid IL or missing references)
			//IL_029d: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_03dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_03fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0436: Unknown result type (might be due to invalid IL or missing references)
			//IL_052c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0541: Unknown result type (might be due to invalid IL or missing references)
			//IL_0546: Unknown result type (might be due to invalid IL or missing references)
			//IL_054b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0754: Unknown result type (might be due to invalid IL or missing references)
			//IL_0769: Unknown result type (might be due to invalid IL or missing references)
			//IL_076e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0773: Unknown result type (might be due to invalid IL or missing references)
			//IL_07a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_072a: Unknown result type (might be due to invalid IL or missing references)
			//IL_068d: Unknown result type (might be due to invalid IL or missing references)
			//IL_058b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0591: Unknown result type (might be due to invalid IL or missing references)
			//IL_06e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_070d: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)base.CurrentEnemy == (Object)null || base.CurrentEnemy.isEnemyDead)
			{
				if (wasFleeingJester)
				{
					base.CurrentEnemy = FindNearbyJester();
					if ((Object)(object)base.CurrentEnemy != (Object)null && !base.CurrentEnemy.isEnemyDead)
					{
						return;
					}
				}
				ChangeBackToPreviousState();
				return;
			}
			float? num = base.ai.GetFearRangeForEnemies(base.CurrentEnemy);
			if (!num.HasValue)
			{
				if (wasFleeingJester)
				{
					base.CurrentEnemy = FindNearbyJester();
				}
				else
				{
					ChangeBackToPreviousState();
				}
				return;
			}
			EnemyAI val = base.ai.CheckLOSForEnemy(90f, 40, 5);
			if ((Object)(object)val != (Object)null && (Object)(object)val != (Object)(object)base.CurrentEnemy)
			{
				float? fearRangeForEnemies = base.ai.GetFearRangeForEnemies(val);
				if (fearRangeForEnemies.HasValue)
				{
					base.CurrentEnemy = val;
					num = fearRangeForEnemies.Value;
					calmDownTimer = 0f;
					RestartPanikCoroutine(base.CurrentEnemy, num.Value);
					if (base.CurrentEnemy is JesterAI)
					{
						wasFleeingJester = true;
						if (Time.timeSinceLevelLoad - lastDeclaredJesterTimer > 30f)
						{
							lastDeclaredJesterTimer = Time.timeSinceLevelLoad;
							base.ai.SendChatMessage("JESTER!!! RUN!!!", bypassConfig: true);
						}
					}
				}
			}
			if (calmDownTimer > 0f && !base.CurrentEnemy.isOutside)
			{
				base.ai.StopMoving();
				bool flag = true;
				if (LethalBotManager.Instance.LootTransferPlayers.Count > 0)
				{
					flag = false;
				}
				if (base.ai.HasScrapInInventory())
				{
					base.ai.State = new ReturnToShipState(this, !flag);
				}
				else if (base.previousState.GetValueOrDefault() == EnumAIStates.ReturnToShip || base.previousState.GetValueOrDefault() == EnumAIStates.ChillAtShip)
				{
					base.ai.State = new ReturnToShipState(this, !flag);
				}
				else if (ShouldReturnToShip())
				{
					base.ai.State = new ReturnToShipState(this);
				}
				else if (calmDownTimer > 70f)
				{
					base.ai.State = new SearchingForScrapState(this, targetEntrance);
				}
				else if (calmDownTimer > 10f && IsEntranceSafe(targetEntrance, useEntrancePoint: true))
				{
					ChangeBackToPreviousState();
				}
				else
				{
					calmDownTimer += ((EnemyAI)base.ai).AIIntervalTime;
				}
				return;
			}
			Vector3 placePosition = ((Component)npcController.Npc).transform.position - ((Component)base.CurrentEnemy).transform.position;
			float sqrMagnitude = ((Vector3)(ref placePosition)).sqrMagnitude;
			if (!(base.CurrentEnemy is JesterAI) && Physics.Linecast(((Component)base.CurrentEnemy).transform.position, ((Component)npcController.Npc.gameplayCamera).transform.position, StartOfRound.Instance.collidersAndRoomMaskAndDefault, (QueryTriggerInteraction)1) && sqrMagnitude > 25f)
			{
				if (breakLOSTimer > 4f)
				{
					if (wasFleeingJester)
					{
						base.CurrentEnemy = FindNearbyJester();
					}
					else
					{
						ChangeBackToPreviousState();
					}
					return;
				}
				breakLOSTimer += ((EnemyAI)base.ai).AIIntervalTime;
			}
			else
			{
				breakLOSTimer = 0f;
			}
			if (sqrMagnitude > num * num)
			{
				if (wasFleeingJester)
				{
					base.CurrentEnemy = FindNearbyJester();
				}
				else
				{
					ChangeBackToPreviousState();
				}
				return;
			}
			if (panikCoroutine == null)
			{
				if (RetreatPos.HasValue)
				{
					placePosition = RetreatPos.Value - ((Component)npcController.Npc).transform.position;
					if (!(((Vector3)(ref placePosition)).sqrMagnitude < 1f) && (!updateRetreatPosTimer.HasStarted() || !updateRetreatPosTimer.Elapsed()) && base.ai.IsValidPathToTarget(RetreatPos.Value))
					{
						goto IL_0460;
					}
				}
				RestartPanikCoroutine(base.CurrentEnemy, num.Value);
			}
			goto IL_0460;
			IL_0460:
			if (base.ai.HasCombatWeapon() && base.ai.CanEnemyBeKilled(base.CurrentEnemy, (Object)(object)LethalBotManager.Instance.MissionControlPlayer == (Object)(object)npcController.Npc))
			{
				base.ai.State = new FightEnemyState(this, base.CurrentEnemy, previousAIState);
			}
			else
			{
				if (CounterEnemy(base.CurrentEnemy))
				{
					return;
				}
				if (findEntranceTimer > 2f)
				{
					findEntranceTimer = 0f;
					targetEntrance = FindClosestEntrance();
				}
				else
				{
					findEntranceTimer += ((EnemyAI)base.ai).AIIntervalTime;
				}
				if ((Object)(object)targetEntrance != (Object)null)
				{
					placePosition = targetEntrance.entrancePoint.position - ((Component)npcController.Npc).transform.position;
					float sqrMagnitude2 = ((Vector3)(ref placePosition)).sqrMagnitude;
					bool isPathVaild;
					if (sqrMagnitude2 < 1f)
					{
						if (!base.ai.AreHandsFree() && base.ai.HeldItem is CaveDwellerPhysicsProp)
						{
							LethalBotAI lethalBotAI2 = base.ai;
							placePosition = default(Vector3);
							lethalBotAI2.DropItem(placeObject: false, null, placePosition);
							return;
						}
						if (Time.timeSinceLevelLoad - base.ai.TimeSinceTeleporting > 1f)
						{
							Vector3? entranceTeleportPos = base.ai.GetTeleportPosOfEntrance(targetEntrance);
							if (entranceTeleportPos.HasValue)
							{
								base.ai.StopMoving();
								if (base.LethalBotInteraction == null || base.LethalBotInteraction.IsCompleted)
								{
									EntranceTeleport entrance = targetEntrance;
									base.LethalBotInteraction = new LethalBotInteraction(PatchesUtil.triggerScriptField.Invoke(entrance), delegate(LethalBotAI lethalBotAI, PlayerControllerB lethalBotController, InteractTrigger _)
									{
										//IL_0021: Unknown result type (might be due to invalid IL or missing references)
										//IL_0098: Unknown result type (might be due to invalid IL or missing references)
										Plugin.LogDebug("======== TeleportLethalBotAndSync " + lethalBotController.playerUsername + " !!!!!!!!!!!!!!! ");
										Vector3 value = entranceTeleportPos.Value;
										EntranceTeleport obj = entrance;
										lethalBotAI.SyncTeleportLethalBot(value, (obj != null) ? (!obj.isEntranceToBuilding) : (!((EnemyAI)lethalBotAI).isOutside), entrance);
										calmDownTimer = ((EnemyAI)lethalBotAI).AIIntervalTime;
										if ((Object)(object)((EnemyAI)lethalBotAI).targetPlayer != (Object)null && ((EnemyAI)lethalBotAI).targetPlayer.isInsideFactory)
										{
											previousStateUpdate.TargetLastKnownPosition = entranceTeleportPos.Value;
										}
									}, ignoreInteractablility: false, skipOriginalInteract: true);
								}
							}
							else
							{
								targetEntrance = null;
								findEntranceTimer = 0f;
								RestartPanikCoroutine(base.CurrentEnemy, num.Value);
							}
						}
					}
					else if (sqrMagnitude2 < 400f || base.CurrentEnemy is JesterAI || !base.ai.PathIsIntersectedByLineOfSight(targetEntrance.entrancePoint.position, out isPathVaild, calculatePathDistance: false, avoidLineOfSight: true, base.CurrentEnemy))
					{
						Plugin.LogDebug("Safe path to nearby entrance, setting retreat pos to entrance!");
						StopPanikCoroutine();
						if ((Object)(object)LethalBotAI.ElevatorScript != (Object)null && !base.ai.IsInElevatorStartRoom && !base.ai.IsValidPathToTarget(targetEntrance.entrancePoint.position))
						{
							base.ai.UseElevator(goUp: true);
							RetreatPos = ((EnemyAI)base.ai).destination;
						}
						else
						{
							RetreatPos = targetEntrance.entrancePoint.position;
						}
					}
				}
				if (RetreatPos.HasValue)
				{
					placePosition = RetreatPos.Value - ((Component)npcController.Npc).transform.position;
					if (!(((Vector3)(ref placePosition)).sqrMagnitude > 1f))
					{
						base.ai.StopMoving();
						return;
					}
				}
				if (RetreatPos.HasValue)
				{
					base.ai.SetDestinationToPositionLethalBotAI(RetreatPos.Value);
				}
				npcController.OrderToSprint();
				base.ai.OrderMoveToDestination();
			}
		}

		public override void StopAllCoroutines()
		{
			base.StopAllCoroutines();
			StopPanikCoroutine();
		}

		public override void TryPlayCurrentStateVoiceAudio()
		{
			if (!(calmDownTimer > 0f))
			{
				base.ai.LethalBotIdentity.Voice.TryPlayVoiceAudio(new PlayVoiceParameters
				{
					VoiceState = EnumVoicesState.RunningFromMonster,
					CanTalkIfOtherLethalBotTalk = true,
					WaitForCooldown = false,
					CutCurrentVoiceStateToTalk = true,
					CanRepeatVoiceState = (!(base.CurrentEnemy is NutcrackerEnemyAI) || base.CurrentEnemy.currentBehaviourStateIndex != 1),
					ShouldSync = true,
					IsLethalBotInside = npcController.Npc.isInsideFactory,
					AllowSwearing = Plugin.Config.AllowSwearing.Value
				});
			}
		}

		public override void OnBotStuck()
		{
			base.OnBotStuck();
			if ((Object)(object)base.CurrentEnemy != (Object)null)
			{
				RestartPanikCoroutine(base.CurrentEnemy, base.ai.GetFearRangeForEnemies(base.CurrentEnemy).GetValueOrDefault(20f));
			}
		}

		public new static void RegisterChatCommands()
		{
			ChatCommandsManager.RegisterIgnoreDefaultForState<PanikState>();
			ChatCommandsManager.RegisterCommandForState<PanikState>(new ChatCommand("jester", delegate(AIState state, LethalBotAI lethalBotAI, PlayerControllerB playerWhoSentMessage, string message, bool isVoice)
			{
				PanikState panikState = (PanikState)state;
				if (panikState.CurrentEnemy is JesterAI || ((EnemyAI)lethalBotAI).isOutside)
				{
					return true;
				}
				EnemyAI val = panikState.FindNearbyJester();
				if ((Object)(object)val == (Object)null)
				{
					return true;
				}
				panikState.wasFleeingJester = true;
				panikState.CurrentEnemy = val;
				panikState.calmDownTimer = 0f;
				float? fearRangeForEnemies = lethalBotAI.GetFearRangeForEnemies(panikState.CurrentEnemy);
				if (fearRangeForEnemies.HasValue)
				{
					panikState.RestartPanikCoroutine(panikState.CurrentEnemy, fearRangeForEnemies.Value);
					if (Time.timeSinceLevelLoad - panikState.lastDeclaredJesterTimer > 30f)
					{
						panikState.lastDeclaredJesterTimer = Time.timeSinceLevelLoad;
						lethalBotAI.SendChatMessage("JESTER!!! RUN!!!", bypassConfig: true);
					}
				}
				return true;
			}));
		}

		public new static void RegisterSignalTranslatorCommands()
		{
			ChatCommandsManager.RegisterCommandForState<PanikState>(new ChatCommand("return", delegate(AIState state, LethalBotAI lethalBotAI, PlayerControllerB playerWhoSentMessage, string message, bool isVoice)
			{
				PanikState panikState2 = (PanikState)state;
				panikState2.previousAIState = new ReturnToShipState(state);
				return true;
			}));
			ChatCommandsManager.RegisterCommandForState<PanikState>(new ChatCommand("jester", delegate(AIState state, LethalBotAI lethalBotAI, PlayerControllerB playerWhoSentMessage, string message, bool isVoice)
			{
				PanikState panikState = (PanikState)state;
				panikState.lastDeclaredJesterTimer = Time.timeSinceLevelLoad;
				if (panikState.CurrentEnemy is JesterAI || ((EnemyAI)lethalBotAI).isOutside)
				{
					return true;
				}
				EnemyAI val = panikState.FindNearbyJester();
				if ((Object)(object)val == (Object)null)
				{
					return true;
				}
				panikState.wasFleeingJester = true;
				panikState.CurrentEnemy = val;
				panikState.calmDownTimer = 0f;
				float? fearRangeForEnemies = lethalBotAI.GetFearRangeForEnemies(panikState.CurrentEnemy);
				if (fearRangeForEnemies.HasValue)
				{
					panikState.RestartPanikCoroutine(panikState.CurrentEnemy, fearRangeForEnemies.Value);
					return true;
				}
				return true;
			}));
		}

		public override bool? ShouldBotCrouch()
		{
			return false;
		}

		public override void UseHeldItem()
		{
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			GrabbableObject heldItem = base.ai.HeldItem;
			CaveDwellerPhysicsProp val = (CaveDwellerPhysicsProp)(object)((heldItem is CaveDwellerPhysicsProp) ? heldItem : null);
			if (val != null)
			{
				CaveDwellerAI caveDwellerScript = val.caveDwellerScript;
				if ((Object)(object)caveDwellerScript == (Object)null || !caveDwellerScript.babyCrying)
				{
					base.ai.DropItem();
					return;
				}
			}
			else if (heldItem is NoisemakerProp)
			{
				return;
			}
			base.UseHeldItem();
		}

		public override string GetBillboardStateIndicator()
		{
			return "/!\\";
		}

		private bool CounterEnemy(EnemyAI CurrentEnemy)
		{
			if (CurrentEnemy is SpringManAI || CurrentEnemy is FlowermanAI)
			{
				npcController.OrderToLookAtPosition(((NetworkBehaviour)CurrentEnemy).NetworkObject, EnumLookAtPriority.HIGH_PRIORITY, 1f);
			}
			else if (CurrentEnemy is CentipedeAI || CurrentEnemy is CrawlerAI || CurrentEnemy is MaskedPlayerEnemy || CurrentEnemy is BushWolfEnemy || (CurrentEnemy is CadaverBloomAI && CurrentEnemy.isInsidePlayerShip))
			{
				if (!base.ai.HasCombatWeapon())
				{
					float maxRange = ((CurrentEnemy is MaskedPlayerEnemy || CurrentEnemy is CrawlerAI) ? 4f : 15f);
					GrabbableObject val = FindNearbyWeapon(maxRange);
					if ((Object)(object)val != (Object)null)
					{
						base.ai.State = new FetchingObjectState(this, val, EnumGrabbableObjectCall.Default, null, ignoreEnemies: true);
						return true;
					}
				}
			}
			else
			{
				PumaAI val2 = (PumaAI)(object)((CurrentEnemy is PumaAI) ? CurrentEnemy : null);
				if (val2 != null)
				{
					npcController.OrderToLookAtPosition(((NetworkBehaviour)CurrentEnemy).NetworkObject, EnumLookAtPriority.HIGH_PRIORITY, 1f);
					if (PatchesUtil.stalkingFrozenField.Invoke(val2))
					{
						return true;
					}
					float maxRange2 = 4f;
					GrabbableObject val3 = FindNearbyWeapon(maxRange2);
					if ((Object)(object)val3 != (Object)null)
					{
						base.ai.State = new FetchingObjectState(this, val3, EnumGrabbableObjectCall.Default, null, ignoreEnemies: true);
						return true;
					}
				}
				else if (CurrentEnemy is NutcrackerEnemyAI && CurrentEnemy.currentBehaviourStateIndex == 1)
				{
					base.ai.StopMoving();
					return true;
				}
			}
			return false;
		}

		private GrabbableObject? FindNearbyWeapon(float maxRange = 15f)
		{
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			GrabbableObject result = null;
			float num = maxRange * maxRange;
			for (int i = 0; i < LethalBotManager.grabbableObjectsInMap.Count; i++)
			{
				GameObject val = LethalBotManager.grabbableObjectsInMap[i];
				if ((Object)(object)val == (Object)null)
				{
					LethalBotManager.grabbableObjectsInMap.TrimExcess();
					continue;
				}
				GrabbableObject component = val.GetComponent<GrabbableObject>();
				if ((Object)(object)component != (Object)null && base.ai.HasAmmoForWeapon(component))
				{
					LethalBotAI.DictJustDroppedItems.Remove(component);
					Vector3 val2 = ((Component)component).transform.position - ((Component)npcController.Npc).transform.position;
					float sqrMagnitude = ((Vector3)(ref val2)).sqrMagnitude;
					if (sqrMagnitude < num && base.ai.IsGrabbableObjectGrabbable(component))
					{
						num = sqrMagnitude;
						result = component;
					}
				}
			}
			return result;
		}

		[IteratorStateMachine(typeof(<ChooseFleeingNodeFromPosition>d__25))]
		private IEnumerator ChooseFleeingNodeFromPosition(EnemyAI enemy, float fearRange)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <ChooseFleeingNodeFromPosition>d__25(0)
			{
				<>4__this = this,
				enemy = enemy,
				fearRange = fearRange
			};
		}

		protected override void ChangeBackToPreviousState()
		{
			if ((base.previousState.GetValueOrDefault() == EnumAIStates.SearchingForScrap || (base.previousState.GetValueOrDefault() == EnumAIStates.FetchingObject && ((Object)(object)((EnemyAI)base.ai).targetPlayer == (Object)null || !((EnemyAI)base.ai).targetPlayer.isPlayerControlled || ((EnemyAI)base.ai).targetPlayer.isPlayerDead))) && base.ai.HasScrapInInventory())
			{
				bool flag = true;
				if (LethalBotManager.Instance.LootTransferPlayers.Count > 0)
				{
					flag = false;
				}
				base.ai.State = new ReturnToShipState(this, !flag, new SearchingForScrapState(this));
			}
			else
			{
				base.ChangeBackToPreviousState();
			}
		}

		protected override EntranceTeleport? FindClosestEntrance(EntranceTeleport? entranceToAvoid, Vector3? shipPos = null)
		{
			if (((EnemyAI)base.ai).isOutside)
			{
				return null;
			}
			return base.FindClosestEntrance(entranceToAvoid, shipPos);
		}

		protected override EntranceTeleport? FindClosestEntrance(Vector3? shipPos = null, HashSet<EntranceTeleport>? entrancesToAvoid = null)
		{
			if (((EnemyAI)base.ai).isOutside)
			{
				return null;
			}
			return base.FindClosestEntrance(shipPos, entrancesToAvoid);
		}

		private void StartPanikCoroutine(EnemyAI CurrentEnemy, float fearRange)
		{
			panikCoroutine = ((MonoBehaviour)base.ai).StartCoroutine(ChooseFleeingNodeFromPosition(CurrentEnemy, fearRange));
		}

		private void RestartPanikCoroutine(EnemyAI CurrentEnemy, float fearRange)
		{
			StopPanikCoroutine();
			StartPanikCoroutine(CurrentEnemy, fearRange);
		}

		private void StopPanikCoroutine()
		{
			if (panikCoroutine != null)
			{
				((MonoBehaviour)base.ai).StopCoroutine(panikCoroutine);
				panikCoroutine = null;
			}
		}
	}
	public class PlayerInCruiserState : AIState
	{
		private VehicleController? vehicleController;

		public PlayerInCruiserState(AIState state, VehicleController vehicleController)
			: base(state)
		{
			base.CurrentState = EnumAIStates.PlayerInCruiser;
			this.vehicleController = vehicleController;
		}

		public PlayerInCruiserState(LethalBotAI ai, VehicleController? vehicleController)
			: base(ai)
		{
			base.CurrentState = EnumAIStates.PlayerInCruiser;
			this.vehicleController = vehicleController;
		}

		public override void DoAI()
		{
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: 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)
			//IL_013a: Unknown result type (might be due to invalid IL or missing references)
			//IL_014a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0150: Unknown result type (might be due to invalid IL or missing references)
			//IL_0155: Unknown result type (might be due to invalid IL or missing references)
			//IL_015a: Unknown result type (might be due to invalid IL or missing references)
			//IL_015f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0166: Unknown result type (might be due to invalid IL or missing references)
			//IL_016e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0199: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b8: Unknown result type (might be due to invalid IL or missing references)
			base.ai.SetAgent(enabled: false);
			if ((Object)(object)vehicleController == (Object)null)
			{
				base.ai.State = new GetCloseToPlayerState(this);
				return;
			}
			Vector3 pos = ((Component)vehicleController).transform.position + ((Component)vehicleController).transform.rotation * GetNextRandomEntryPosCruiser();
			if (npcController.IsControllerInCruiser)
			{
				if ((Object)(object)base.ai.GetVehicleCruiserTargetPlayerIsIn() == (Object)null)
				{
					base.ai.SyncTeleportLethalBotVehicle(pos, enteringVehicle: false, NetworkBehaviourReference.op_Implicit((NetworkBehaviour)(object)vehicleController));
					vehicleController.SetVehicleCollisionForPlayer(true, npcController.Npc);
					base.ai.State = new GetCloseToPlayerState(this);
				}
				return;
			}
			if ((Object)(object)((EnemyAI)base.ai).targetPlayer == (Object)null || !((EnemyAI)base.ai).PlayerIsTargetable(((EnemyAI)base.ai).targetPlayer, false, false, true))
			{
				base.ai.State = new SearchingForPlayerState(this);
				return;
			}
			EnemyAI val = base.ai.CheckLOSForEnemy(90f, 40, 5);
			if ((Object)(object)val != (Object)null)
			{
				base.ai.State = new PanikState(this, val);
				return;
			}
			Vector3 pos2 = ((Component)vehicleController).transform.position + ((Component)vehicleController).transform.rotation * GetNextRandomInCruiserPos();
			base.ai.SyncTeleportLethalBotVehicle(pos2, enteringVehicle: true, NetworkBehaviourReference.op_Implicit((NetworkBehaviour)(object)vehicleController));
			float num = Random.Range(-180f, 180f);
			npcController.UpdateNowTurnBodyTowardsDirection(Quaternion.Euler(0f, num, 0f) * ((Component)npcController.Npc.thisController).transform.forward);
			float num2 = Random.Range(0f, 1f);
			if (num2 > 0.5f && !npcController.Npc.isCrouching)
			{
				npcController.OrderToToggleCrouch();
			}
			npcController.StopAnimations();
			npcController.OrderToStopMoving();
		}

		public override void TryPlayCurrentStateVoiceAudio()
		{
			base.ai.LethalBotIdentity.Voice.TryPlayVoiceAudio(new PlayVoiceParameters
			{
				VoiceState = EnumVoicesState.EnteringCruiser,
				CanTalkIfOtherLethalBotTalk = false,
				WaitForCooldown = true,
				CutCurrentVoiceStateToTalk = false,
				CanRepeatVoiceState = true,
				ShouldSync = true,
				IsLethalBotInside = npcController.Npc.isInsideFactory,
				AllowSwearing = Plugin.Config.AllowSwearing.Value
			});
		}

		public new static void RegisterSignalTranslatorCommands()
		{
			SignalTranslatorCommandsManager.RegisterIgnoreDefaultForState<PlayerInCruiserState>();
		}

		private Vector3 GetNextRandomInCruiserPos()
		{
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			float num = Random.Range(Const.FIRST_CORNER_LETHALBOT_IN_CRUISER.x, Const.SECOND_CORNER_LETHALBOT_IN_CRUISER.x);
			float num2 = Random.Range(Const.FIRST_CORNER_LETHALBOT_IN_CRUISER.y, Const.SECOND_CORNER_LETHALBOT_IN_CRUISER.y);
			float num3 = Random.Range(Const.FIRST_CORNER_LETHALBOT_IN_CRUISER.z, Const.SECOND_CORNER_LETHALBOT_IN_CRUISER.z);
			return new Vector3(num, num2, num3);
		}

		private Vector3 GetNextRandomEntryPosCruiser()
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			float num = Random.Range(Const.POS1_ENTRY_LETHALBOT_CRUISER.x, Const.POS2_ENTRY_LETHALBOT_CRUISER.x);
			return new Vector3(num, Const.POS1_ENTRY_LETHALBOT_CRUISER.y, Const.POS1_ENTRY_LETHALBOT_CRUISER.z);
		}
	}
	public class RescueAndReviveState : AIState
	{
		public enum ReviveMethod
		{
			None,
			ModReviveCompany,
			ModBunkbedRevive,
			ModZaprillator,
			ModUsualScrap
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass35_0
		{
			public RescueAndReviveState <>4__this;

			public int itemSlot;

			public float startTime;

			public PatcherTool patcherTool;

			internal bool <reviveUsingZaprillator>b__0()
			{
				if (<>4__this.npcController.LookAtTarget.IsHeadAimingOnTarget())
				{
					return <>4__this.npcController.LookAtTarget.hasBeenSightedIn;
				}
				return false;
			}

			internal bool <reviveUsingZaprillator>b__1()
			{
				if (<>4__this.npcController.Npc.currentItemSlot != itemSlot)
				{
					return Time.timeSinceLevelLoad - startTime > 1f;
				}
				return true;
			}

			internal bool <reviveUsingZaprillator>b__2()
			{
				if (!((Object)(object)patcherTool == (Object)null))
				{
					return !isScanning.Invoke(patcherTool);
				}
				return true;
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass37_0
		{
			public RescueAndReviveState <>4__this;

			public int itemSlot;

			public float startTime;

			internal bool <reviveUsualScrapLogic>b__0()
			{
				if (<>4__this.npcController.LookAtTarget.IsHeadAimingOnTarget())
				{
					return <>4__this.npcController.LookAtTarget.hasBeenSightedIn;
				}
				return false;
			}

			internal bool <reviveUsualScrapLogic>b__1()
			{
				if (<>4__this.npcController.Npc.currentItemSlot != itemSlot)
				{
					return Time.timeSinceLevelLoad - startTime > 1f;
				}
				return true;
			}
		}

		[CompilerGenerated]
		private sealed class <findFallbackSpot>d__30 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public RescueAndReviveState <>4__this;

			private List<GameObject> <nodes>5__2;

			private Turret[] <turrets>5__3;

			private SpikeRoofTrap[] <spikeRoofTraps>5__4;

			private bool <ourWeOutside>5__5;

			private float <headOffset>5__6;

			private int <i>5__7;

			private GameObject <node>5__8;

			private Vector3? <nodePos>5__9;

			private bool <isNodeSafe>5__10;

			private Vector3 <simulatedHead>5__11;

			private RoundManager <instanceRM>5__12;

			private int <j>5__13;

			private EnemyAI <checkLOSToTarget>5__14;

			private Turret <turret>5__15;

			private SpikeRoofTrap <spikeRoofTrap>5__16;

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

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

			[DebuggerHidden]
			public <findFallbackSpot>d__30(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<nodes>5__2 = null;
				<turrets>5__3 = null;
				<spikeRoofTraps>5__4 = null;
				<node>5__8 = null;
				<instanceRM>5__12 = null;
				<checkLOSToTarget>5__14 = null;
				<turret>5__15 = null;
				<spikeRoofTrap>5__16 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
				//IL_0162: Unknown result type (might be due to invalid IL or missing references)
				//IL_0401: Unknown result type (might be due to invalid IL or missing references)
				//IL_0406: Unknown result type (might be due to invalid IL or missing references)
				//IL_0408: Unknown result type (might be due to invalid IL or missing references)
				//IL_040b: Unknown result type (might be due to invalid IL or missing references)
				//IL_04ce: Unknown result type (might be due to invalid IL or missing references)
				//IL_04d3: Unknown result type (might be due to invalid IL or missing references)
				//IL_04d5: Unknown result type (might be due to invalid IL or missing references)
				//IL_04dd: Unknown result type (might be due to invalid IL or missing references)
				//IL_04e2: Unknown result type (might be due to invalid IL or missing references)
				//IL_04e7: Unknown result type (might be due to invalid IL or missing references)
				//IL_018d: Unknown result type (might be due to invalid IL or missing references)
				//IL_027e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0283: Unknown result type (might be due to invalid IL or missing references)
				//IL_01b5: Unknown result type (might be due to invalid IL or missing references)
				//IL_01ba: Unknown result type (might be due to invalid IL or missing references)
				//IL_01c5: Unknown result type (might be due to invalid IL or missing references)
				//IL_01ca: Unknown result type (might be due to invalid IL or missing references)
				//IL_01cf: Unknown result type (might be due to invalid IL or missing references)
				//IL_0291: Unknown result type (might be due to invalid IL or missing references)
				//IL_0299: Unknown result type (might be due to invalid IL or missing references)
				//IL_029e: Unknown result type (might be due to invalid IL or missing references)
				//IL_02a3: Unknown result type (might be due to invalid IL or missing references)
				//IL_054f: Unknown result type (might be due to invalid IL or missing references)
				//IL_056a: Unknown result type (might be due to invalid IL or missing references)
				//IL_031d: Unknown result type (might be due to invalid IL or missing references)
				//IL_030e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0322: Unknown result type (might be due to invalid IL or missing references)
				//IL_0324: Unknown result type (might be due to invalid IL or missing references)
				//IL_0326: Unknown result type (might be due to invalid IL or missing references)
				//IL_0330: Unknown result type (might be due to invalid IL or missing references)
				//IL_0335: Unknown result type (might be due to invalid IL or missing references)
				//IL_033b: Unknown result type (might be due to invalid IL or missing references)
				int num = <>1__state;
				RescueAndReviveState CS$<>8__locals0 = <>4__this;
				GameObject obj;
				Vector3 val;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					CS$<>8__locals0.fallbackPos = null;
					<nodes>5__2 = ((EnemyAI)CS$<>8__locals0.ai).allAINodes.OrderBy(delegate(GameObject node)
					{
						//IL_0006: Unknown result type (might be due to invalid IL or missing references)
						//IL_001b: Unknown result type (might be due to invalid IL or missing references)
						//IL_0020: Unknown result type (might be due to invalid IL or missing references)
						//IL_0025: Unknown result type (might be due to invalid IL or missing references)
						Vector3 val3 = node.transform.position - ((Component)CS$<>8__locals0.npcController.Npc).transform.position;
						return ((Vector3)(ref val3)).sqrMagnitude;
					}).ToList();
					<nodes>5__2.Insert(0, ((Component)CS$<>8__locals0.npcController.Npc).gameObject);
					<turrets>5__3 = Object.FindObjectsOfType<Turret>();
					<spikeRoofTraps>5__4 = Object.FindObjectsOfType<SpikeRoofTrap>();
					<>2__current = null;
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<ourWeOutside>5__5 = ((EnemyAI)CS$<>8__locals0.ai).isOutside;
					<headOffset>5__6 = ((Component)CS$<>8__locals0.npcController.Npc.gameplayCamera).transform.position.y - ((Component)CS$<>8__locals0.npcController.Npc).transform.position.y;
					<i>5__7 = 0;
					goto IL_058d;
				case 2:
					<>1__state = -1;
					goto IL_0147;
				case 3:
					<>1__state = -1;
					goto IL_0229;
				case 4:
					<>1__state = -1;
					goto IL_03db;
				case 5:
					{
						<>1__state = -1;
						goto IL_04a3;
					}
					IL_058d:
					if (<i>5__7 >= <nodes>5__2.Count)
					{
						break;
					}
					<node>5__8 = <nodes>5__2[<i>5__7];
					if (<i>5__7 % 15 == 0)
					{
						<>2__current = null;
						<>1__state = 2;
						return true;
					}
					goto IL_0147;
					IL_038f:
					if (<isNodeSafe>5__10)
					{
						<j>5__13 = 0;
						goto IL_0444;
					}
					goto IL_057b;
					IL_0444:
					if (<j>5__13 < <turrets>5__3.Length)
					{
						<turret>5__15 = <turrets>5__3[<j>5__13];
						if (<j>5__13 % 15 == 0)
						{
							<>2__current = null;
							<>1__state = 4;
							return true;
						}
						goto IL_03db;
					}
					goto IL_0457;
					IL_0147:
					obj = <node>5__8;
					<nodePos>5__9 = ((obj != null) ? new Vector3?(obj.transform.position) : null);
					if (<nodePos>5__9.HasValue && CS$<>8__locals0.ai.IsValidPathToTarget(<nodePos>5__9.Value))
					{
						<isNodeSafe>5__10 = true;
						<simulatedHead>5__11 = <nodePos>5__9.Value + Vector3.up * <headOffset>5__6;
						<instanceRM>5__12 = RoundManager.Instance;
						<j>5__13 = 0;
						goto IL_0374;
					}
					goto IL_057b;
					IL_03db:
					if (!((Object)(object)<turret>5__15 == (Object)null) && ((Behaviour)<turret>5__15).isActiveAndEnabled)
					{
						Vector3 position = <turret>5__15.aimPoint.position;
						if (!Physics.Linecast(position, <simulatedHead>5__11, StartOfRound.Instance.collidersAndRoomMaskAndDefault, (QueryTriggerInteraction)1))
						{
							<isNodeSafe>5__10 = false;
							goto IL_0457;
						}
						<turret>5__15 = null;
					}
					<j>5__13++;
					goto IL_0444;
					IL_052c:
					if (<isNodeSafe>5__10)
					{
						Plugin.LogDebug($"Bot {CS$<>8__locals0.npcController.Npc.playerUsername} found fallback spot at {<nodePos>5__9.Value}!");
						CS$<>8__locals0.fallbackPos = <nodePos>5__9.Value;
						break;
					}
					goto IL_057b;
					IL_04a3:
					if (!((Object)(object)<spikeRoofTrap>5__16 == (Object)null) && ((Behaviour)<spikeRoofTrap>5__16).isActiveAndEnabled)
					{
						Vector3 position2 = ((Component)<spikeRoofTrap>5__16.spikeTrapAudio).transform.position;
						val = position2 - <nodePos>5__9.Value;
						if (((Vector3)(ref val)).sqrMagnitude <= 400f)
						{
							<isNodeSafe>5__10 = false;
							goto IL_052c;
						}
						<spikeRoofTrap>5__16 = null;
					}
					<j>5__13++;
					goto IL_0519;
					IL_057b:
					<i>5__7++;
					goto IL_058d;
					IL_0374:
					if (<j>5__13 < <instanceRM>5__12.SpawnedEnemies.Count)
					{
						<checkLOSToTarget>5__14 = <instanceRM>5__12.SpawnedEnemies[<j>5__13];
						if (<j>5__13 % 10 == 0)
						{
							<>2__current = null;
							<>1__state = 3;
							return true;
						}
						goto IL_0229;
					}
					goto IL_038f;
					IL_0457:
					if (<isNodeSafe>5__10)
					{
						<j>5__13 = 0;
						goto IL_0519;
					}
					goto IL_057b;
					IL_0229:
					if (!((Object)(object)<checkLOSToTarget>5__14 == (Object)null) && !<checkLOSToTarget>5__14.isEnemyDead && <ourWeOutside>5__5 == <checkLOSToTarget>5__14.isOutside)
					{
						float? fearRangeForEnemies = CS$<>8__locals0.ai.GetFearRangeForEnemies(<checkLOSToTarget>5__14, EnumFearQueryType.PathfindingAvoid);
						Vector3 position3 = ((Component)<checkLOSToTarget>5__14).transform.position;
						if (fearRangeForEnemies.HasValue)
						{
							val = position3 - <nodePos>5__9.Value;
							if (((Vector3)(ref val)).sqrMagnitude <= fearRangeForEnemies * fearRangeForEnemies)
							{
								Vector3 val2 = (((Object)(object)<checkLOSToTarget>5__14.eye != (Object)null) ? <checkLOSToTarget>5__14.eye.position : position3);
								if (!Physics.Linecast(val2 + Vector3.up * 0.2f, <simulatedHead>5__11, StartOfRound.Instance.collidersAndRoomMaskAndDefault, (QueryTriggerInteraction)1))
								{
									<isNodeSafe>5__10 = false;
									goto IL_038f;
								}
							}
						}
						<checkLOSToTarget>5__14 = null;
					}
					<j>5__13++;
					goto IL_0374;
					IL_0519:
					if (<j>5__13 < <spikeRoofTraps>5__4.Length)
					{
						<spikeRoofTrap>5__16 = <spikeRoofTraps>5__4[<j>5__13];
						if (<j>5__13 % 15 == 0)
						{
							<>2__current = null;
							<>1__state = 5;
							return true;
						}
						goto IL_04a3;
					}
					goto IL_052c;
				}
				CS$<>8__locals0.StopFallbackCoroutine();
				return false;
			}

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

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

		[CompilerGenerated]
		private sealed class <reviveUsingReviveCompany>d__33 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public RescueAndReviveState <>4__this;

			private RagdollGrabbableObject <playerBody>5__2;

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

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

			[DebuggerHidden]
			public <reviveUsingReviveCompany>d__33(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<playerBody>5__2 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
				//IL_00fe: Expected O, but got Unknown
				//IL_0114: Unknown result type (might be due to invalid IL or missing references)
				//IL_011e: Expected O, but got Unknown
				//IL_01e3: Unknown result type (might be due to invalid IL or missing references)
				//IL_01e9: Expected O, but got Unknown
				//IL_0268: Unknown result type (might be due to invalid IL or missing references)
				//IL_026e: Expected O, but got Unknown
				int num = <>1__state;
				RescueAndReviveState CS$<>8__locals0 = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
				{
					<>1__state = -1;
					CS$<>8__locals0.allowRecharging = false;
					ref RagdollGrabbableObject reference = ref <playerBody>5__2;
					GrabbableObject grabBodyObject = CS$<>8__locals0.playerToRevive.deadBody.grabBodyObject;
					reference = (RagdollGrabbableObject)(object)((grabBodyObject is RagdollGrabbableObject) ? grabBodyObject : null);
					if ((Object)(object)<playerBody>5__2 == (Object)null)
					{
						Plugin.LogError("[" + CS$<>8__locals0.npcController.Npc.playerUsername + "] Tried to revive player " + CS$<>8__locals0.playerToRevive.playerUsername + " using Revive Company but their body is not a RagdollGrabbableObject!");
						CS$<>8__locals0.StopReviveCoroutine();
						return false;
					}
					CS$<>8__locals0.npcController.OrderToLookAtPosition(((NetworkBehaviour)<playerBody>5__2).NetworkObject, EnumLookAtPriority.HIGH_PRIORITY);
					<>2__current = null;
					<>1__state = 1;
					return true;
				}
				case 1:
					<>1__state = -1;
					<>2__current = (object)new WaitUntil((Func<bool>)(() => CS$<>8__locals0.npcController.LookAtTarget.IsHeadAimingOnTarget() && CS$<>8__locals0.npcController.LookAtTarget.hasBeenSightedIn));
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					<>2__current = (object)new WaitForSeconds(ConfigVariables.reviveTime);
					<>1__state = 3;
					return true;
				case 3:
				{
					<>1__state = -1;
					if ((Object)(object)CS$<>8__locals0.playerToRevive == (Object)null || !ReviveCompanyCanRevivePlayer(CS$<>8__locals0.ai, CS$<>8__locals0.playerToRevive))
					{
						CS$<>8__locals0.StopReviveCoroutine();
						return false;
					}
					if ((Object)(object)<playerBody>5__2 == (Object)null)
					{
						Plugin.LogError("[" + CS$<>8__locals0.npcController.Npc.playerUsername + "] Tried to revive player " + CS$<>8__locals0.playerToRevive.playerUsername + " using Revive Company but their body is not a RagdollGrabbableObject!");
						CS$<>8__locals0.StopReviveCoroutine();
						return false;
					}
					RpcMessage val = new RpcMessage((MessageTasks)1, <playerBody>5__2.ragdoll.playerScript.playerClientId.ToString(), (int)GameNetworkManager.Instance.localPlayerController.playerClientId, (MessageCodes)0);
					RpcMessageHandler.SendRpcMessage(val);
					ResponseHandler.SentMessageNeedResponses(val);
					GeneralUtil.RevivePlayer((int)<playerBody>5__2.ragdoll.playerScript.playerClientId);
					LethalBotAI[] lethalBotAIs = LethalBotManager.Instance.GetLethalBotAIs();
					foreach (LethalBotAI lethalBotAI in lethalBotAIs)
					{
						ResponseHandler.RecievedResponse((MessageTasks)1);
					}
					RpcMessage val2 = new RpcMessage((MessageTasks)2, <playerBody>5__2.ragdoll.playerScript.playerClientId.ToString(), (int)GameNetworkManager.Instance.localPlayerController.playerClientId, (MessageCodes)0);
					RpcMessageHandler.SendRpcMessage(val2);
					CS$<>8__locals0.StopReviveCoroutine();
					return false;
				}
				}
			}

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

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

		[CompilerGenerated]
		private sealed class <reviveUsingZaprillator>d__35 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public RescueAndReviveState <>4__this;

			private <>c__DisplayClass35_0 <>8__1;

			private RagdollGrabbableObject <playerBody>5__2;

			private GrabbableObject <heldItem>5__3;

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

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

			[DebuggerHidden]
			public <reviveUsingZaprillator>d__35(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>8__1 = null;
				<playerBody>5__2 = null;
				<heldItem>5__3 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_012d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0137: Expected O, but got Unknown
				//IL_033b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0345: Expected O, but got Unknown
				//IL_0267: Unknown result type (might be due to invalid IL or missing references)
				//IL_0271: Expected O, but got Unknown
				//IL_04de: Unknown result type (might be due to invalid IL or missing references)
				//IL_04e8: Expected O, but got Unknown
				//IL_0584: Unknown result type (might be due to invalid IL or missing references)
				//IL_058e: Expected O, but got Unknown
				//IL_03d0: Unknown result type (might be due to invalid IL or missing references)
				//IL_03e5: Unknown result type (might be due to invalid IL or missing references)
				//IL_03ea: Unknown result type (might be due to invalid IL or missing references)
				//IL_03f4: Unknown result type (might be due to invalid IL or missing references)
				//IL_03f9: Unknown result type (might be due to invalid IL or missing references)
				//IL_0409: Unknown result type (might be due to invalid IL or missing references)
				//IL_040e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0413: Unknown result type (might be due to invalid IL or missing references)
				//IL_041d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0422: Unknown result type (might be due to invalid IL or missing references)
				//IL_0430: Unknown result type (might be due to invalid IL or missing references)
				//IL_0441: Unknown result type (might be due to invalid IL or missing references)
				//IL_044b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0455: Unknown result type (might be due to invalid IL or missing references)
				//IL_047f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0471: Unknown result type (might be due to invalid IL or missing references)
				//IL_0484: Unknown result type (might be due to invalid IL or missing references)
				//IL_048c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0490: Unknown result type (might be due to invalid IL or missing references)
				//IL_0496: Unknown result type (might be due to invalid IL or missing references)
				//IL_049e: Unknown result type (might be due to invalid IL or missing references)
				//IL_020b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0211: Unknown result type (might be due to invalid IL or missing references)
				int num = <>1__state;
				RescueAndReviveState rescueAndReviveState = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
				{
					<>1__state = -1;
					<>8__1 = new <>c__DisplayClass35_0();
					<>8__1.<>4__this = <>4__this;
					rescueAndReviveState.allowRecharging = false;
					ref RagdollGrabbableObject reference = ref <playerBody>5__2;
					GrabbableObject grabBodyObject = rescueAndReviveState.playerToRevive.deadBody.grabBodyObject;
					reference = (RagdollGrabbableObject)(object)((grabBodyObject is RagdollGrabbableObject) ? grabBodyObject : null);
					if ((Object)(object)<playerBody>5__2 == (Object)null)
					{
						Plugin.LogError("[" + rescueAndReviveState.npcController.Npc.playerUsername + "] Tried to revive player " + rescueAndReviveState.playerToRevive.playerUsername + " using Zaprillator but their body is not a RagdollGrabbableObject!");
						rescueAndReviveState.StopReviveCoroutine();
						return false;
					}
					rescueAndReviveState.npcController.OrderToLookAtPosition(((NetworkBehaviour)<playerBody>5__2).NetworkObject, EnumLookAtPriority.HIGH_PRIORITY);
					<>2__current = null;
					<>1__state = 1;
					return true;
				}
				case 1:
					<>1__state = -1;
					<>2__current = (object)new WaitUntil((Func<bool>)(() => <>8__1.<>4__this.npcController.LookAtTarget.IsHeadAimingOnTarget() && <>8__1.<>4__this.npcController.LookAtTarget.hasBeenSightedIn));
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					if (!rescueAndReviveState.ai.HasGrabbableObjectInInventory((Func<GrabbableObject, bool>)FindZapGun, out <>8__1.itemSlot))
					{
						Plugin.LogWarning("[" + rescueAndReviveState.npcController.Npc.playerUsername + "] Tried to revive player " + rescueAndReviveState.playerToRevive.playerUsername + " using Zaprillator but they don't have a zap gun!");
						rescueAndReviveState.StopReviveCoroutine();
						return false;
					}
					if (!rescueAndReviveState.ai.AreHandsFree() && !(rescueAndReviveState.ai.HeldItem is PatcherTool) && rescueAndReviveState.ai.HeldItem.itemProperties.twoHanded)
					{
						rescueAndReviveState.ai.DropItem();
						<>2__current = null;
						<>1__state = 3;
						return true;
					}
					goto IL_022f;
				case 3:
					<>1__state = -1;
					goto IL_022f;
				case 4:
				{
					<>1__state = -1;
					<heldItem>5__3 = rescueAndReviveState.ai.HeldItem;
					ref PatcherTool patcherTool = ref <>8__1.patcherTool;
					GrabbableObject obj = <heldItem>5__3;
					patcherTool = (PatcherTool)(object)((obj is PatcherTool) ? obj : null);
					if (<>8__1.patcherTool == null)
					{
						Plugin.LogWarning("[" + rescueAndReviveState.npcController.Npc.playerUsername + "] Tried to revive player " + rescueAndReviveState.playerToRevive.playerUsername + " using Zaprillator but they either don't have a zap gun or item switch failed!");
						rescueAndReviveState.StopReviveCoroutine();
						return false;
					}
					<heldItem>5__3.UseItemOnClient(true);
					<>2__current = null;
					<>1__state = 5;
					return true;
				}
				case 5:
					<>1__state = -1;
					<>2__current = (object)new WaitUntil((Func<bool>)(() => (Object)(object)<>8__1.patcherTool == (Object)null || !isScanning.Invoke(<>8__1.patcherTool)));
					<>1__state = 6;
					return true;
				case 6:
					<>1__state = -1;
					if (!<>8__1.patcherTool.isShocking)
					{
						Plugin.LogWarning("[" + rescueAndReviveState.npcController.Npc.playerUsername + "] Tried to revive player " + rescueAndReviveState.playerToRevive.playerUsername + " using Zaprillator but the Zap Gun failed to find the body!");
						if (!rescueAndReviveState.movedFromFallback)
						{
							Ray val = default(Ray);
							((Ray)(ref val))..ctor(((Component)rescueAndReviveState.npcController.Npc).transform.position, ((Component)rescueAndReviveState.npcController.Npc).transform.position + Vector3.up * 0.2f - ((Component)<playerBody>5__2).transform.position + Vector3.up * 0.2f);
							((Ray)(ref val)).direction = new Vector3(((Ray)(ref val)).direction.x, 0f, ((Ray)(ref val)).direction.z);
							RaycastHit val2 = default(RaycastHit);
							Vector3 val3 = ((!Physics.Raycast(val, ref val2, 4f, StartOfRound.Instance.collidersAndRoomMaskAndDefault, (QueryTriggerInteraction)1)) ? ((Ray)(ref val)).GetPoint(4f) : ((RaycastHit)(ref val2)).point);
							rescueAndReviveState.fallbackPos = RoundManager.Instance.GetNavMeshPosition(val3, default(NavMeshHit), 2.7f, -1);
							rescueAndReviveState.movedFromFallback = true;
						}
						else
						{
							rescueAndReviveState.fallbackPos = null;
							rescueAndReviveState.movedFromFallback = false;
							rescueAndReviveState.shouldPickupBody = true;
						}
						rescueAndReviveState.StopReviveCoroutine();
						return false;
					}
					<>2__current = (object)new WaitForSeconds(1f);
					<>1__state = 7;
					return true;
				case 7:
					<>1__state = -1;
					<>2__current = null;
					<>1__state = 8;
					return true;
				case 8:
					<>1__state = -1;
					if (<>8__1.patcherTool.isShocking)
					{
						<heldItem>5__3.UseItemOnClient(true);
						Plugin.LogWarning("[" + rescueAndReviveState.npcController.Npc.playerUsername + "] Tried to revive player " + rescueAndReviveState.playerToRevive.playerUsername + " using Zaprillator but the Zap Gun hit the wrong target!");
						rescueAndReviveState.StopReviveCoroutine();
						return false;
					}
					<>2__current = (object)new WaitForSeconds(1f);
					<>1__state = 9;
					return true;
				case 9:
					{
						<>1__state = -1;
						rescueAndReviveState.StopReviveCoroutine();
						return false;
					}
					IL_022f:
					<>8__1.startTime = Time.timeSinceLevelLoad;
					rescueAndReviveState.ai.SwitchItemSlotsAndSync(<>8__1.itemSlot);
					<>2__current = (object)new WaitUntil((Func<bool>)(() => <>8__1.<>4__this.npcController.Npc.currentItemSlot == <>8__1.itemSlot || Time.timeSinceLevelLoad - <>8__1.startTime > 1f));
					<>1__state = 4;
					return true;
				}
			}

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

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

		[CompilerGenerated]
		private sealed class <reviveUsualScrapLogic>d__37 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public RescueAndReviveState <>4__this;

			private <>c__DisplayClass37_0 <>8__1;

			private GrabbableObject <heldItem>5__2;

			private FieldInfo <timeToHoldField>5__3;

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

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

			[DebuggerHidden]
			public <reviveUsualScrapLogic>d__37(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>8__1 = null;
				<heldItem>5__2 = null;
				<timeToHoldField>5__3 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_011e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0128: Expected O, but got Unknown
				//IL_03e7: Unknown result type (might be due to invalid IL or missing references)
				//IL_03f1: Expected O, but got Unknown
				//IL_0258: Unknown result type (might be due to invalid IL or missing references)
				//IL_0262: Expected O, but got Unknown
				//IL_03a4: Unknown result type (might be due to invalid IL or missing references)
				//IL_03ae: Expected O, but got Unknown
				//IL_01fc: Unknown result type (might be due to invalid IL or missing references)
				//IL_0202: Unknown result type (might be due to invalid IL or missing references)
				int num = <>1__state;
				RescueAndReviveState rescueAndReviveState = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
				{
					<>1__state = -1;
					<>8__1 = new <>c__DisplayClass37_0();
					<>8__1.<>4__this = <>4__this;
					rescueAndReviveState.allowRecharging = false;
					GrabbableObject grabBodyObject = rescueAndReviveState.playerToRevive.deadBody.grabBodyObject;
					RagdollGrabbableObject val = (RagdollGrabbableObject)(object)((grabBodyObject is RagdollGrabbableObject) ? grabBodyObject : null);
					if ((Object)(object)val == (Object)null)
					{
						Plugin.LogError("[" + rescueAndReviveState.npcController.Npc.playerUsername + "] Tried to revive player " + rescueAndReviveState.playerToRevive.playerUsername + " using Usual Scrap but their body is not a RagdollGrabbableObject!");
						rescueAndReviveState.StopReviveCoroutine();
						return false;
					}
					rescueAndReviveState.npcController.OrderToLookAtPosition(((NetworkBehaviour)val).NetworkObject, EnumLookAtPriority.HIGH_PRIORITY);
					<>2__current = null;
					<>1__state = 1;
					return true;
				}
				case 1:
					<>1__state = -1;
					<>2__current = (object)new WaitUntil((Func<bool>)(() => <>8__1.<>4__this.npcController.LookAtTarget.IsHeadAimingOnTarget() && <>8__1.<>4__this.npcController.LookAtTarget.hasBeenSightedIn));
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					if (!rescueAndReviveState.ai.HasGrabbableObjectInInventory((Func<GrabbableObject, bool>)FindDefibUnit, out <>8__1.itemSlot))
					{
						Plugin.LogWarning("[" + rescueAndReviveState.npcController.Npc.playerUsername + "] Tried to revive player " + rescueAndReviveState.playerToRevive.playerUsername + " using Usual Scrap but they don't have a defibrillator!");
						rescueAndReviveState.StopReviveCoroutine();
						return false;
					}
					if (!rescueAndReviveState.ai.AreHandsFree() && !IsUsualScrapDefibUnit(rescueAndReviveState.ai.HeldItem) && rescueAndReviveState.ai.HeldItem.itemProperties.twoHanded)
					{
						rescueAndReviveState.ai.DropItem();
						<>2__current = null;
						<>1__state = 3;
						return true;
					}
					goto IL_0220;
				case 3:
					<>1__state = -1;
					goto IL_0220;
				case 4:
					<>1__state = -1;
					<heldItem>5__2 = rescueAndReviveState.ai.HeldItem;
					if (!IsUsualScrapDefibUnit(<heldItem>5__2))
					{
						Plugin.LogWarning("[" + rescueAndReviveState.npcController.Npc.playerUsername + "] Tried to revive player " + rescueAndReviveState.playerToRevive.playerUsername + " using Usual Scrap but they either don't have a defibrillator or item switch failed!");
						rescueAndReviveState.StopReviveCoroutine();
						return false;
					}
					<timeToHoldField>5__3 = AccessTools.Field(typeof(DefibrillatorScript), "timeToHold");
					<heldItem>5__2.UseItemOnClient(true);
					<>2__current = null;
					<>1__state = 5;
					return true;
				case 5:
					<>1__state = -1;
					<>8__1.startTime = Time.timeSinceLevelLoad;
					goto IL_0369;
				case 6:
					<>1__state = -1;
					goto IL_0369;
				case 7:
					<>1__state = -1;
					<>2__current = null;
					<>1__state = 8;
					return true;
				case 8:
					<>1__state = -1;
					<heldItem>5__2.UseItemOnClient(false);
					<>2__current = (object)new WaitForSeconds(1f);
					<>1__state = 9;
					return true;
				case 9:
					{
						<>1__state = -1;
						rescueAndReviveState.StopReviveCoroutine();
						return false;
					}
					IL_0369:
					if (Time.timeSinceLevelLoad - <>8__1.startTime < 4f && CanUsualScrapDefibUnitBeUsed(<heldItem>5__2))
					{
						float num2 = (int)<timeToHoldField>5__3.GetValue(<heldItem>5__2);
						if (!(num2 <= 0f))
						{
							<>2__current = null;
							<>1__state = 6;
							return true;
						}
					}
					<>2__current = (object)new WaitForSeconds(Random.Range(0f, 0.5f) + 0.05f);
					<>1__state = 7;
					return true;
					IL_0220:
					<>8__1.startTime = Time.timeSinceLevelLoad;
					rescueAndReviveState.ai.SwitchItemSlotsAndSync(<>8__1.itemSlot);
					<>2__current = (object)new WaitUntil((Func<bool>)(() => <>8__1.<>4__this.npcController.Npc.currentItemSlot == <>8__1.itemSlot || Time.timeSinceLevelLoad - <>8__1.startTime > 1f));
					<>1__state = 4;
					return true;
				}
			}

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

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

		private static Func<RagdollGrabbableObject, bool>? ReviveCompanyCanReviveDelegate = null;

		private static Action<int>? BunkbedReviveRPCDelegate = null;

		private static readonly FieldRef<PatcherTool, bool> isScanning = (FieldRef<PatcherTool, bool>)(object)AccessTools.FieldRefAccess<bool>(typeof(PatcherTool), "isScanning");

		private PlayerControllerB playerToRevive;

		private GrabbableObject? neededReviveTool;

		private ReviveMethod reviveMethod;

		private Coroutine? fallbackCoroutine;

		private Coroutine? reviveCoroutine;

		private Vector3? fallbackPos;

		private bool shouldPickupBody;

		private bool allowRecharging;

		private bool movedFromFallback;

		public RescueAndReviveState(AIState oldState, PlayerControllerB playerToRevive)
			: base(oldState)
		{
			base.CurrentState = EnumAIStates.RescueAndRevive;
			this.playerToRevive = playerToRevive;
		}

		public RescueAndReviveState(LethalBotAI ai, PlayerControllerB playerToRevive)
			: base(ai)
		{
			base.CurrentState = EnumAIStates.RescueAndRevive;
			this.playerToRevive = playerToRevive;
		}

		public override void OnEnterState()
		{
			if (!hasBeenStarted)
			{
				if (!IsAnyReviveModInstalled())
				{
					Plugin.LogWarning("[" + npcController.Npc.playerUsername + "] RescueAndReviveState entered but no revive mods are loaded! Reverting to previous state.");
					ChangeBackToPreviousState();
					return;
				}
				reviveMethod = DetermineBestReviveMethod();
			}
			shouldPickupBody = true;
			allowRecharging = true;
			StartFallbackCoroutine();
			base.OnEnterState();
		}

		public override void OnExitState(AIState newState)
		{
			GrabbableObject? heldItem = base.ai.HeldItem;
			PatcherTool val = (PatcherTool)(object)((heldItem is PatcherTool) ? heldItem : null);
			if (val != null && val.isShocking)
			{
				((GrabbableObject)val).UseItemOnClient(true);
			}
			base.OnExitState(newState);
		}

		public override void DoAI()
		{
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			EnemyAI val = base.ai.CheckLOSForEnemy(90f, 40, 5);
			if ((Object)(object)val != (Object)null)
			{
				base.ai.State = new PanikState(this, val);
				return;
			}
			if ((Object)(object)playerToRevive == (Object)null || !playerToRevive.isPlayerDead)
			{
				ChangeBackToPreviousState();
				return;
			}
			if (!CanRevivePlayer())
			{
				Plugin.LogInfo($"[{npcController.Npc.playerUsername}] Cannot revive player {playerToRevive.playerUsername} with method {reviveMethod}. Reverting to previous state.");
				ChangeBackToPreviousState();
				return;
			}
			if (shouldPickupBody)
			{
				GrabbableObject heldItem = base.ai.HeldItem;
				GrabbableObject grabBodyObject = playerToRevive.deadBody.grabBodyObject;
				if ((Object)(object)heldItem == (Object)null || (Object)(object)heldItem != (Object)(object)grabBodyObject)
				{
					if ((Object)(object)heldItem != (Object)null && (heldItem.itemProperties.twoHanded || !base.ai.HasSpaceInInventory()))
					{
						base.ai.DropItem();
					}
					LethalBotAI.DictJustDroppedItems.Remove(grabBodyObject);
					if (base.ai.IsGrabbableObjectGrabbable(grabBodyObject, EnumGrabbableObjectCall.Reviving))
					{
						base.ai.State = new FetchingObjectState(this, grabBodyObject, EnumGrabbableObjectCall.Reviving);
						return;
					}
					Plugin.LogWarning("[" + npcController.Npc.playerUsername + "] Cannot grab dead body of player " + playerToRevive.playerUsername + ". Reverting to previous state.");
					ChangeBackToPreviousState();
					return;
				}
			}
			GrabbableObject val2 = neededReviveTool;
			if ((Object)(object)val2 != (Object)null)
			{
				neededReviveTool = null;
				base.ai.State = new FetchingObjectState(this, val2);
				return;
			}
			if (allowRecharging && (npcController.Npc.isInElevator || npcController.Npc.isInHangarShipRoom) && ChargeHeldItemState.HasItemToCharge(base.ai, out GrabbableObject _))
			{
				base.ai.State = new ChargeHeldItemState(this, chargeAllHeldItems: true);
				return;
			}
			switch (reviveMethod)
			{
			case ReviveMethod.ModReviveCompany:
				DoReviveCompanyLogic();
				break;
			case ReviveMethod.ModZaprillator:
				DoZaprillatorLogic();
				break;
			case ReviveMethod.ModBunkbedRevive:
				StopFallbackCoroutine();
				DoBunkBedReviveLogic();
				break;
			case ReviveMethod.ModUsualScrap:
				DoUsualScrapLogic();
				break;
			}
		}

		public override void TryPlayCurrentStateVoiceAudio()
		{
		}

		public override void StopAllCoroutines()
		{
			base.StopAllCoroutines();
			StopFallbackCoroutine();
			StopReviveCoroutine();
		}

		protected override Vector3? GetDesiredSafePathPosition()
		{
			return fallbackPos;
		}

		private ReviveMethod DetermineBestReviveMethod()
		{
			if (Plugin.IsModReviveCompanyLoaded && ReviveCompanyCanRevivePlayer(base.ai, playerToRevive))
			{
				return ReviveMethod.ModReviveCompany;
			}
			if (Plugin.IsModZaprillatorLoaded && ZaprillatorCanRevivePlayer(base.ai, playerToRevive))
			{
				return ReviveMethod.ModZaprillator;
			}
			if (Plugin.IsModBunkbedReviveLoaded && BunkbedReviveCanRevivePlayer(base.ai, playerToRevive))
			{
				return ReviveMethod.ModBunkbedRevive;
			}
			if (Plugin.IsModUsualScrapLoaded && UsualScrapCanRevivePlayer(base.ai, playerToRevive))
			{
				return ReviveMethod.ModUsualScrap;
			}
			return ReviveMethod.None;
		}

		private static bool ReviveCompanyCanRevivePlayer(LethalBotAI lethalBotAI, PlayerControllerB playerToRevive, bool isMissionController = false)
		{
			if (Plugin.IsModReviveCompanyLoaded)
			{
				if (ReviveCompanyCanReviveDelegate == null)
				{
					try
					{
						MethodInfo methodInfo = AccessTools.Method(AccessTools.TypeByName("OPJosMod.ReviveCompany.Patches.PlayerControllerBPatch"), "canRevive", (Type[])null, (Type[])null);
						if (methodInfo != null)
						{
							ReviveCompanyCanReviveDelegate = (Func<RagdollGrabbableObject, bool>)Delegate.CreateDelegate(typeof(Func<RagdollGrabbableObject, bool>), methodInfo);
						}
					}
					catch (Exception ex)
					{
						Plugin.LogError(ex.Message);
					}
					if (ReviveCompanyCanReviveDelegate == null)
					{
						Plugin.LogInfo("Failed to create Delegate!?");
						return false;
					}
				}
				if (isMissionController && ConfigVariables.reviveTeleportedBodies)
				{
					return false;
				}
				if (playerToRevive?.deadBody?.grabBodyObject is RagdollGrabbableObject || (Object)(object)playerToRevive == (Object)(object)GameNetworkManager.Instance.localPlayerController)
				{
					GrabbableObject obj = playerToRevive?.deadBody?.grabBodyObject;
					RagdollGrabbableObject val = (RagdollGrabbableObject)(object)((obj is RagdollGrabbableObject) ? obj : null);
					if ((Object)(object)playerToRevive == (Object)(object)GameNetworkManager.Instance.localPlayerController)
					{
						if (GlobalVariables.RemainingRevives <= 0)
						{
							return false;
						}
						int num = (int)playerToRevive.playerClientId;
						if (GeneralUtil.HasPlayerTeleported(num) && !ConfigVariables.reviveTeleportedBodies)
						{
							return false;
						}
						Plugin.LogInfo(Time.time + " | " + GeneralUtil.GetPlayersDiedAtTime(num));
						if (Time.time - GeneralUtil.GetPlayersDiedAtTime(num) > (float)ConfigVariables.TimeUnitlCantBeRevived && !ConfigVariables.InfiniteReviveTime)
						{
							return false;
						}
						return true;
					}
					if ((Object)(object)val != (Object)null)
					{
						return ReviveCompanyCanReviveDelegate(val);
					}
				}
			}
			return false;
		}

		private static bool ZaprillatorCanRevivePlayer(LethalBotAI lethalBotAI, PlayerControllerB playerToRevive, bool isMissionController = false)
		{
			if (Plugin.IsModZaprillatorLoaded)
			{
				if (lethalBotAI.HasGrabbableObjectInInventory((Func<GrabbableObject, bool>)FindZapGun, out int _))
				{
					return true;
				}
				PlayerControllerB npc = lethalBotAI.NpcController.Npc;
				if (npc.isInElevator || npc.isInHangarShipRoom)
				{
					return (Object)(object)lethalBotAI.FindItemOnShip(FindZapGun) != (Object)null;
				}
			}
			return false;
		}

		private static bool BunkbedReviveCanRevivePlayer(LethalBotAI lethalBotAI, PlayerControllerB playerToRevive, bool isMissionController = false)
		{
			if (isMissionController || (!lethalBotAI.NpcController.Npc.isInElevator && !lethalBotAI.NpcController.Npc.isInHangarShipRoom))
			{
				return false;
			}
			if (BunkbedReviveRPCDelegate == null)
			{
				try
				{
					MethodInfo methodInfo = AccessTools.Method(AccessTools.TypeByName("BunkbedRevive.BunkbedNetworking"), "RevivePlayerServerRpc", (Type[])null, (Type[])null);
					if (methodInfo != null)
					{
						BunkbedReviveRPCDelegate = (Action<int>)Delegate.CreateDelegate(typeof(Action<int>), methodInfo);
					}
				}
				catch (Exception ex)
				{
					Plugin.LogError(ex.Message);
				}
				if (BunkbedReviveRPCDelegate == null)
				{
					return false;
				}
			}
			if (Plugin.IsModBunkbedReviveLoaded)
			{
				int reviveCost = BunkbedController.GetReviveCost();
				int valueOrDefault = (TerminalManager.Instance?.GetTerminal()?.groupCredits).GetValueOrDefault();
				if (valueOrDefault < reviveCost)
				{
					return false;
				}
				return BunkbedController.CanRevive((int)playerToRevive.playerClientId, true);
			}
			return false;
		}

		private static bool UsualScrapCanRevivePlayer(LethalBotAI lethalBotAI, PlayerControllerB playerToRevive, bool isMissionController = false)
		{
			if (Plugin.IsModUsualScrapLoaded)
			{
				if (lethalBotAI.HasGrabbableObjectInInventory((Func<GrabbableObject, bool>)FindDefibUnit, out int objectSlot))
				{
					GrabbableObject itemAtSlot = lethalBotAI.GetItemAtSlot(objectSlot);
					if (UsualScrapCanBodyBeRevived(itemAtSlot, playerToRevive))
					{
						return true;
					}
				}
				PlayerControllerB npc = lethalBotAI.NpcController.Npc;
				if (npc.isInElevator || npc.isInHangarShipRoom)
				{
					GrabbableObject val = lethalBotAI.FindItemOnShip(FindDefibUnit);
					if (val != null)
					{
						return UsualScrapCanBodyBeRevived(val, playerToRevive);
					}
					return false;
				}
			}
			return false;
		}

		private static bool UsualScrapCanBodyBeRevived(GrabbableObject? defibUnit, PlayerControllerB playerToRevive)
		{
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Invalid comparison between Unknown and I4
			DefibrillatorScript val = (DefibrillatorScript)(object)((defibUnit is DefibrillatorScript) ? defibUnit : null);
			if (val != null)
			{
				FieldInfo fieldInfo = AccessTools.Field(typeof(DefibrillatorScript), "PermaDeathRule");
				if (!(bool)fieldInfo.GetValue(val))
				{
					return true;
				}
				DeadBodyInfo deadBody = playerToRevive.deadBody;
				if ((Object)(object)deadBody != (Object)null)
				{
					if ((int)deadBody.causeOfDeath != 17)
					{
						return !deadBody.detachedHead;
					}
					return false;
				}
			}
			return false;
		}

		private bool CanRevivePlayer()
		{
			return reviveMethod switch
			{
				ReviveMethod.ModReviveCompany => ReviveCompanyCanRevivePlayer(base.ai, playerToRevive), 
				ReviveMethod.ModBunkbedRevive => BunkbedReviveCanRevivePlayer(base.ai, playerToRevive), 
				ReviveMethod.ModZaprillator => ZaprillatorCanRevivePlayer(base.ai, playerToRevive), 
				ReviveMethod.ModUsualScrap => UsualScrapCanRevivePlayer(base.ai, playerToRevive), 
				_ => false, 
			};
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool IsAnyReviveModInstalled()
		{
			if (!Plugin.IsModReviveCompanyLoaded && !Plugin.IsModBunkbedReviveLoaded && !Plugin.IsModZaprillatorLoaded)
			{
				return Plugin.IsModUsualScrapLoaded;
			}
			return true;
		}

		public static bool CanRevivePlayer(LethalBotAI lethalBotAI, PlayerControllerB playerController, bool isMissionController = false)
		{
			GrabbableObject val = playerController.deadBody?.grabBodyObject;
			if ((Object)(object)val == (Object)null || !playerController.isPlayerDead)
			{
				return false;
			}
			if (Plugin.IsModReviveCompanyLoaded && ReviveCompanyCanRevivePlayer(lethalBotAI, playerController, isMissionController))
			{
				return true;
			}
			if (Plugin.IsModZaprillatorLoaded && ZaprillatorCanRevivePlayer(lethalBotAI, playerController, isMissionController))
			{
				return true;
			}
			if (Plugin.IsModUsualScrapLoaded && UsualScrapCanRevivePlayer(lethalBotAI, playerController, isMissionController))
			{
				return true;
			}
			if (Plugin.IsModBunkbedReviveLoaded && BunkbedReviveCanRevivePlayer(lethalBotAI, playerController, isMissionController))
			{
				return true;
			}
			return false;
		}

		[IteratorStateMachine(typeof(<findFallbackSpot>d__30))]
		private IEnumerator findFallbackSpot()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <findFallbackSpot>d__30(0)
			{
				<>4__this = this
			};
		}

		private void StartFallbackCoroutine()
		{
			if (fallbackCoroutine == null)
			{
				fallbackCoroutine = ((MonoBehaviour)base.ai).StartCoroutine(findFallbackSpot());
			}
		}

		private void StopFallbackCoroutine()
		{
			if (fallbackCoroutine != null)
			{
				((MonoBehaviour)base.ai).StopCoroutine(fallbackCoroutine);
				fallbackCoroutine = null;
			}
		}

		[IteratorStateMachine(typeof(<reviveUsingReviveCompany>d__33))]
		private IEnumerator reviveUsingReviveCompany()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <reviveUsingReviveCompany>d__33(0)
			{
				<>4__this = this
			};
		}

		private void DoReviveCompanyLogic()
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0148: Unknown result type (might be due to invalid IL or missing references)
			//IL_014e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			if (!fallbackPos.HasValue || !base.ai.IsValidPathToTarget(fallbackPos.Value))
			{
				StartFallbackCoroutine();
				return;
			}
			Vector3 placePosition = fallbackPos.Value - ((Component)npcController.Npc).transform.position;
			float sqrMagnitude = ((Vector3)(ref placePosition)).sqrMagnitude;
			if (sqrMagnitude >= 1f)
			{
				StartSafePathCoroutine();
				SelectBestItemFromInventory();
				placePosition = safePathPos - ((Component)npcController.Npc).transform.position;
				float sqrMagnitude2 = ((Vector3)(ref placePosition)).sqrMagnitude;
				if (sqrMagnitude2 >= 1f)
				{
					base.ai.SetDestinationToPositionLethalBotAI(safePathPos);
					if (!npcController.WaitForFullStamina && sqrMagnitude2 > 64f)
					{
						npcController.OrderToSprint();
					}
					else
					{
						npcController.OrderToStopSprint();
					}
					base.ai.OrderMoveToDestination();
				}
				else
				{
					base.ai.StopMoving();
					npcController.OrderToStopSprint();
				}
			}
			else
			{
				base.ai.StopMoving();
				npcController.OrderToStopSprint();
				StopSafePathCoroutine();
				shouldPickupBody = false;
				if (!base.ai.AreHandsFree())
				{
					LethalBotAI lethalBotAI = base.ai;
					placePosition = default(Vector3);
					lethalBotAI.DropItem(placeObject: false, null, placePosition);
				}
				else if (reviveCoroutine == null)
				{
					reviveCoroutine = ((MonoBehaviour)base.ai).StartCoroutine(reviveUsingReviveCompany());
				}
			}
		}

		[IteratorStateMachine(typeof(<reviveUsingZaprillator>d__35))]
		private IEnumerator reviveUsingZaprillator()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <reviveUsingZaprillator>d__35(0)
			{
				<>4__this = this
			};
		}

		private void DoZaprillatorLogic()
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: Unknown result type (might be due to invalid IL or missing references)
			//IL_0117: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: Unknown result type (might be due to invalid IL or missing references)
			//IL_0139: Unknown result type (might be due to invalid IL or missing references)
			//IL_01df: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e5: Unknown result type (might be due to invalid IL or missing references)
			if (!fallbackPos.HasValue || !base.ai.IsValidPathToTarget(fallbackPos.Value))
			{
				StartFallbackCoroutine();
				return;
			}
			if (!base.ai.HasGrabbableObjectInInventory((Func<GrabbableObject, bool>)FindZapGun, out int _))
			{
				shouldPickupBody = true;
				neededReviveTool = base.ai.FindItemOnShip(FindZapGun);
				if ((Object)(object)neededReviveTool == (Object)null || !base.ai.HasSpaceInInventory(neededReviveTool))
				{
					ChangeBackToPreviousState();
				}
				return;
			}
			Vector3 placePosition = fallbackPos.Value - ((Component)npcController.Npc).transform.position;
			float sqrMagnitude = ((Vector3)(ref placePosition)).sqrMagnitude;
			if (sqrMagnitude >= 1f)
			{
				StartSafePathCoroutine();
				SelectBestItemFromInventory();
				placePosition = safePathPos - ((Component)npcController.Npc).transform.position;
				float sqrMagnitude2 = ((Vector3)(ref placePosition)).sqrMagnitude;
				if (sqrMagnitude2 >= 1f)
				{
					base.ai.SetDestinationToPositionLethalBotAI(safePathPos);
					if (!npcController.WaitForFullStamina && sqrMagnitude2 > 64f)
					{
						npcController.OrderToSprint();
					}
					else
					{
						npcController.OrderToStopSprint();
					}
					base.ai.OrderMoveToDestination();
				}
				else
				{
					base.ai.StopMoving();
					npcController.OrderToStopSprint();
				}
			}
			else
			{
				base.ai.StopMoving();
				npcController.OrderToStopSprint();
				StopSafePathCoroutine();
				shouldPickupBody = false;
				if (!base.ai.AreHandsFree() && !(base.ai.HeldItem is PatcherTool))
				{
					LethalBotAI lethalBotAI = base.ai;
					placePosition = default(Vector3);
					lethalBotAI.DropItem(placeObject: false, null, placePosition);
				}
				else if (reviveCoroutine == null)
				{
					reviveCoroutine = ((MonoBehaviour)base.ai).StartCoroutine(reviveUsingZaprillator());
				}
			}
		}

		[IteratorStateMachine(typeof(<reviveUsualScrapLogic>d__37))]
		private IEnumerator reviveUsualScrapLogic()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <reviveUsualScrapLogic>d__37(0)
			{
				<>4__this = this
			};
		}

		private void DoUsualScrapLogic()
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: Unknown result type (might be due to invalid IL or missing references)
			//IL_0117: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: Unknown result type (might be due to invalid IL or missing references)
			//IL_0139: Unknown result type (might be due to invalid IL or missing references)
			//IL_01df: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e5: Unknown result type (might be due to invalid IL or missing references)
			if (!fallbackPos.HasValue || !base.ai.IsValidPathToTarget(fallbackPos.Value))
			{
				StartFallbackCoroutine();
				return;
			}
			if (!base.ai.HasGrabbableObjectInInventory((Func<GrabbableObject, bool>)FindDefibUnit, out int _))
			{
				shouldPickupBody = true;
				neededReviveTool = base.ai.FindItemOnShip(FindDefibUnit);
				if ((Object)(object)neededReviveTool == (Object)null || !base.ai.HasSpaceInInventory(neededReviveTool))
				{
					ChangeBackToPreviousState();
				}
				return;
			}
			Vector3 placePosition = fallbackPos.Value - ((Component)npcController.Npc).transform.position;
			float sqrMagnitude = ((Vector3)(ref placePosition)).sqrMagnitude;
			if (sqrMagnitude >= 1f)
			{
				StartSafePathCoroutine();
				SelectBestItemFromInventory();
				placePosition = safePathPos - ((Component)npcController.Npc).transform.position;
				float sqrMagnitude2 = ((Vector3)(ref placePosition)).sqrMagnitude;
				if (sqrMagnitude2 >= 1f)
				{
					base.ai.SetDestinationToPositionLethalBotAI(safePathPos);
					if (!npcController.WaitForFullStamina && sqrMagnitude2 > 64f)
					{
						npcController.OrderToSprint();
					}
					else
					{
						npcController.OrderToStopSprint();
					}
					base.ai.OrderMoveToDestination();
				}
				else
				{
					base.ai.StopMoving();
					npcController.OrderToStopSprint();
				}
			}
			else
			{
				base.ai.StopMoving();
				npcController.OrderToStopSprint();
				StopSafePathCoroutine();
				shouldPickupBody = false;
				if (!base.ai.AreHandsFree() && !(base.ai.HeldItem is DefibrillatorScript))
				{
					LethalBotAI lethalBotAI = base.ai;
					placePosition = default(Vector3);
					lethalBotAI.DropItem(placeObject: false, null, placePosition);
				}
				else if (reviveCoroutine == null)
				{
					reviveCoroutine = ((MonoBehaviour)base.ai).StartCoroutine(reviveUsualScrapLogic());
				}
			}
		}

		private void DoBunkBedReviveLogic()
		{
			//IL_001b: 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_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: 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)
			BunkbedController instance = BunkbedController.Instance;
			if ((Object)(object)instance == (Object)null)
			{
				return;
			}
			Vector3 navMeshPosition = RoundManager.Instance.GetNavMeshPosition(((Component)instance).transform.position, default(NavMeshHit), 2.7f, -1);
			Vector3 val = navMeshPosition - ((Component)npcController.Npc).transform.position;
			float sqrMagnitude = ((Vector3)(ref val)).sqrMagnitude;
			if (sqrMagnitude >= 1f)
			{
				base.ai.SetDestinationToPositionLethalBotAI(navMeshPosition);
				SelectBestItemFromInventory();
				if (!npcController.WaitForFullStamina && sqrMagnitude > 64f)
				{
					npcController.OrderToSprint();
				}
				else
				{
					npcController.OrderToStopSprint();
				}
				base.ai.OrderMoveToDestination();
				return;
			}
			base.ai.StopMoving();
			npcController.OrderToStopSprint();
			if (LethalBotManager.Instance.IsPlayerLethalBot(playerToRevive))
			{
				BunkbedReviveBot();
				return;
			}
			GrabbableObject? heldItem = base.ai.HeldItem;
			RagdollGrabbableObject val2 = (RagdollGrabbableObject)(object)((heldItem is RagdollGrabbableObject) ? heldItem : null);
			if ((Object)(object)val2 == (Object)null || BunkbedReviveRPCDelegate == null)
			{
				return;
			}
			int reviveCost = BunkbedController.GetReviveCost();
			if (TerminalManager.Instance.GetTerminal().groupCredits >= reviveCost && BunkbedController.CanRevive(val2.bodyID, true))
			{
				Terminal terminal = TerminalManager.Instance.GetTerminal();
				terminal.groupCredits -= reviveCost;
				LethalBotManager.Instance.SyncGroupCreditsForNotOwnerTerminalServerRpc(terminal.groupCredits, terminal.numberOfItemsInDropship);
				BunkbedReviveRPCDelegate(val2.bodyID);
				PlayerControllerB npc = npcController.Npc;
				if (npc != null)
				{
					npc.DespawnHeldObject();
				}
			}
		}

		private void BunkbedReviveBot()
		{
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			GrabbableObject? heldItem = base.ai.HeldItem;
			RagdollGrabbableObject val = (RagdollGrabbableObject)(object)((heldItem is RagdollGrabbableObject) ? heldItem : null);
			if ((Object)(object)val == (Object)null)
			{
				return;
			}
			int num = (int)val.ragdoll.playerScript.playerClientId;
			string headerText = ((Component)val.ragdoll).gameObject.GetComponentInChildren<ScanNodeProperties>().headerText;
			LethalBotIdentity lethalBotIdentity = IdentityManager.Instance.FindIdentityFromBodyName(headerText);
			if (lethalBotIdentity == null)
			{
				return;
			}
			if (lethalBotIdentity.Alive)
			{
				Plugin.LogError("BunkbedRevive with LethalBot: error when trying to revive bot \"" + lethalBotIdentity.Name + "\", bot is already alive! do nothing more");
				return;
			}
			int reviveCost = BunkbedController.GetReviveCost();
			if (TerminalManager.Instance.GetTerminal().groupCredits >= reviveCost && BunkbedController.CanRevive(val.bodyID, true))
			{
				Terminal terminal = TerminalManager.Instance.GetTerminal();
				terminal.groupCredits -= reviveCost;
				LethalBotManager.Instance.SyncGroupCreditsForNotOwnerTerminalServerRpc(terminal.groupCredits, terminal.numberOfItemsInDropship);
				LethalBotManager.Instance.SpawnThisLethalBotServerRpc(lethalBotIdentity.IdIdentity, new SpawnLethalBotParamsNetworkSerializable
				{
					ShouldDestroyDeadBody = true,
					ResetBodyBlood = true,
					enumSpawnAnimation = EnumSpawnAnimation.OnlyPlayerSpawnAnimation,
					SpawnPosition = StartOfRoundPatch.GetPlayerSpawnPosition_ReversePatch(StartOfRound.Instance, num, simpleTeleport: false),
					YRot = 0f,
					IsOutside = true,
					IndexNextPlayerObject = num
				});
				LethalBotManager.Instance.UpdateReviveCountServerRpc(num);
				StartOfRound instance = StartOfRound.Instance;
				instance.livingPlayers++;
				PlayerControllerB npc = npcController.Npc;
				if (npc != null)
				{
					npc.DespawnHeldObject();
				}
			}
		}

		private static bool FindZapGun(GrabbableObject item)
		{
			PatcherTool val = (PatcherTool)(object)((item is PatcherTool) ? item : null);
			if (val != null)
			{
				if (!((GrabbableObject)val).isInElevator && !((GrabbableObject)val).isInShipRoom)
				{
					return LethalBotAI.IsItemPowered((GrabbableObject?)(object)val);
				}
				return true;
			}
			return false;
		}

		private static bool FindDefibUnit(GrabbableObject item)
		{
			DefibrillatorScript val = (DefibrillatorScript)(object)((item is DefibrillatorScript) ? item : null);
			if (val != null && CanUsualScrapDefibUnitBeUsed((GrabbableObject)(object)val))
			{
				if (!((GrabbableObject)val).isInElevator && !((GrabbableObject)val).isInShipRoom)
				{
					return LethalBotAI.IsItemPowered((GrabbableObject?)(object)val);
				}
				return true;
			}
			return false;
		}

		private static bool CanUsualScrapDefibUnitBeUsed(GrabbableObject item)
		{
			DefibrillatorScript val = (DefibrillatorScript)(object)((item is DefibrillatorScript) ? item : null);
			if (val == null)
			{
				return false;
			}
			FieldInfo fieldInfo = AccessTools.Field(typeof(DefibrillatorScript), "UsesLimited");
			if (!(bool)fieldInfo.GetValue(val))
			{
				return true;
			}
			FieldInfo fieldInfo2 = AccessTools.Field(typeof(DefibrillatorScript), "useLimit");
			return (int)fieldInfo2.GetValue(val) > 0;
		}

		private static bool IsUsualScrapDefibUnit([NotNullWhen(true)] GrabbableObject? item)
		{
			return item is DefibrillatorScript;
		}

		private void StopReviveCoroutine()
		{
			allowRecharging = true;
			if (reviveCoroutine != null)
			{
				((MonoBehaviour)base.ai).StopCoroutine(reviveCoroutine);
				reviveCoroutine = null;
			}
		}
	}
	public class ReturnToShipState : AIState
	{
		private Transform? targetShipTransform;

		private Vector3? targetShipPos;

		private Vector3 targetEntrancePos;

		private bool attemptedToUseTZP;

		private bool endIfOutside;

		private float findEntranceTimer;

		private float shipPositionUpdateTimer;

		public ReturnToShipState(AIState oldState, bool endIfOutside = false, AIState? changeToOnEnd = null)
			: base(oldState, changeToOnEnd)
		{
			base.CurrentState = EnumAIStates.ReturnToShip;
			this.endIfOutside = endIfOutside;
			targetShipTransform = GetRandomInsideShipTransform(allowFallback: false);
			targetShipPos = null;
		}

		public ReturnToShipState(LethalBotAI ai, bool endIfOutside = false, AIState? changeToOnEnd = null)
			: base(ai, changeToOnEnd)
		{
			base.CurrentState = EnumAIStates.ReturnToShip;
			this.endIfOutside = endIfOutside;
			targetShipTransform = GetRandomInsideShipTransform(allowFallback: false);
			targetShipPos = null;
		}

		public override void OnEnterState()
		{
			PlayerControllerB npc = npcController.Npc;
			int groupId = GroupManager.Instance.GetGroupId(npc);
			if (groupId != -1 && (Object)(object)GroupManager.Instance.GetGroupLeader(groupId) != (Object)(object)npc)
			{
				GroupManager.Instance.RemoveFromCurrentGroupAndSync(npc);
			}
			targetEntrance = FindClosestEntrance(GetTargetShipPos());
			findEntranceTimer = 0f;
			base.OnEnterState();
		}

		public override void DoAI()
		{
			//IL_023a: Unknown result type (might be due to invalid IL or missing references)
			//IL_024f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0254: Unknown result type (might be due to invalid IL or missing references)
			//IL_0268: Unknown result type (might be due to invalid IL or missing references)
			//IL_026d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0272: Unknown result type (might be due to invalid IL or missing references)
			//IL_0284: Unknown result type (might be due to invalid IL or missing references)
			//IL_0299: Unknown result type (might be due to invalid IL or missing references)
			//IL_029e: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0190: Unknown result type (might be due to invalid IL or missing references)
			//IL_0195: Unknown result type (might be due to invalid IL or missing references)
			//IL_0197: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01be: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_04cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_04d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_078e: Unknown result type (might be due to invalid IL or missing references)
			//IL_07a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_07a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_07ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_054f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0564: Unknown result type (might be due to invalid IL or missing references)
			//IL_0569: Unknown result type (might be due to invalid IL or missing references)
			//IL_056e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0402: Unknown result type (might be due to invalid IL or missing references)
			//IL_07d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_07e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_07eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_07f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0586: Unknown result type (might be due to invalid IL or missing references)
			//IL_059b: Unknown result type (might be due to invalid IL or missing references)
			//IL_05a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_05a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_080b: Unknown result type (might be due to invalid IL or missing references)
			//IL_05c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_047a: Unknown result type (might be due to invalid IL or missing references)
			//IL_047f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0644: Unknown result type (might be due to invalid IL or missing references)
			//IL_064a: Unknown result type (might be due to invalid IL or missing references)
			//IL_04b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_04b9: Unknown result type (might be due to invalid IL or missing references)
			StartLookingAroundCoroutine();
			EnemyAI val = base.ai.CheckLOSForEnemy(90f, 40, 5);
			if ((Object)(object)val != (Object)null)
			{
				base.ai.State = new PanikState(this, val);
				return;
			}
			PlayerControllerB val2 = base.ai.LookingForPlayerToRevive();
			if ((Object)(object)val2 != (Object)null)
			{
				base.ai.State = new RescueAndReviveState(this, val2);
				return;
			}
			val2 = base.ai.LookingForPlayerToHeal();
			if ((Object)(object)val2 != (Object)null)
			{
				base.ai.State = new HealPlayerState(this, val2);
				return;
			}
			if (base.ai.HasSpaceInInventory())
			{
				GrabbableObject val3 = base.ai.LookingForObjectToGrab();
				if ((Object)(object)val3 != (Object)null)
				{
					base.ai.State = new FetchingObjectState(this, val3);
					return;
				}
				if (!base.ai.searchForScrap.visitInProgress && !((EnemyAI)base.ai).isOutside)
				{
					base.ai.searchForScrap.StartVisit();
				}
			}
			else if (base.ai.searchForScrap.visitInProgress)
			{
				base.ai.searchForScrap.StopSearch();
			}
			int groupId = GroupManager.Instance.GetGroupId(npcController.Npc);
			Vector3 placePosition;
			if (groupId != -1)
			{
				PlayerControllerB groupLeader = GroupManager.Instance.GetGroupLeader(groupId);
				if ((Object)(object)groupLeader == (Object)(object)npcController.Npc)
				{
					PlayerControllerB furthestMemberFromCenter = GroupManager.Instance.GetFurthestMemberFromCenter(groupId);
					if ((Object)(object)furthestMemberFromCenter != (Object)null && !base.ai.AreWeExposed())
					{
						Vector3 groupCenter = GroupManager.Instance.GetGroupCenter(groupLeader, groupId);
						placePosition = Vector3.Scale(groupCenter - ((Component)furthestMemberFromCenter).transform.position, new Vector3(1f, 0f, 1f));
						float sqrMagnitude = ((Vector3)(ref placePosition)).sqrMagnitude;
						placePosition = Vector3.Scale(groupCenter - ((Component)furthestMemberFromCenter).transform.position, new Vector3(0f, 1f, 0f));
						float sqrMagnitude2 = ((Vector3)(ref placePosition)).sqrMagnitude;
						if (sqrMagnitude > 156.25f || sqrMagnitude2 > 625f)
						{
							base.ai.StopMoving();
							return;
						}
					}
				}
				else if ((Object)(object)groupLeader != (Object)null)
				{
					placePosition = Vector3.Scale(((Component)groupLeader).transform.position - ((Component)npcController.Npc).transform.position, new Vector3(1f, 0f, 1f));
					float sqrMagnitude3 = ((Vector3)(ref placePosition)).sqrMagnitude;
					placePosition = Vector3.Scale(((Component)groupLeader).transform.position - ((Component)npcController.Npc).transform.position, new Vector3(0f, 1f, 0f));
					float sqrMagnitude4 = ((Vector3)(ref placePosition)).sqrMagnitude;
					if (sqrMagnitude3 < 625f && sqrMagnitude4 < 2500f)
					{
						base.ai.State = new GetCloseToPlayerState(this, groupLeader);
						return;
					}
					GroupManager.Instance.RemoveFromCurrentGroupAndSync(npcController.Npc);
				}
				else
				{
					GroupManager.Instance.RemoveFromCurrentGroupAndSync(npcController.Npc);
				}
			}
			if (!((EnemyAI)base.ai).isOutside)
			{
				if ((Object)(object)targetEntrance == (Object)null || findEntranceTimer > 10f)
				{
					findEntranceTimer = 0f;
					targetEntrance = FindClosestEntrance(GetTargetShipPos());
					if ((Object)(object)targetEntrance == (Object)null)
					{
						DoorLock val4 = base.ai.UnlockDoorIfNeeded(200f);
						if ((Object)(object)val4 != (Object)null)
						{
							base.ai.State = new UseKeyOnLockedDoorState(this, val4);
						}
						else
						{
							base.ai.State = new LostInFacilityState(this);
						}
						return;
					}
				}
				else
				{
					findEntranceTimer += ((EnemyAI)base.ai).AIIntervalTime;
				}
				if ((Object)(object)LethalBotAI.ElevatorScript != (Object)null && !base.ai.IsInElevatorStartRoom && !base.ai.IsValidPathToTarget(targetEntrance.entrancePoint.position))
				{
					if (!base.ai.UseElevator(goUp: true))
					{
						DoorLock val5 = base.ai.UnlockDoorIfNeeded(200f);
						if ((Object)(object)val5 != (Object)null)
						{
							base.ai.State = new UseKeyOnLockedDoorState(this, val5);
						}
						else
						{
							base.ai.State = new LostInFacilityState(this);
						}
						return;
					}
					targetEntrancePos = ((EnemyAI)base.ai).destination;
					if (!base.ai.AreHandsFree() && base.ai.HeldItem is CaveDwellerPhysicsProp)
					{
						LethalBotAI lethalBotAI2 = base.ai;
						placePosition = default(Vector3);
						lethalBotAI2.DropItem(placeObject: false, null, placePosition);
					}
				}
				else
				{
					targetEntrancePos = targetEntrance.entrancePoint.position;
					if (!base.ai.IsValidPathToTarget(targetEntrance.entrancePoint.position))
					{
						DoorLock val6 = base.ai.UnlockDoorIfNeeded(200f);
						if ((Object)(object)val6 != (Object)null)
						{
							base.ai.State = new UseKeyOnLockedDoorState(this, val6);
							return;
						}
					}
				}
				StartSafePathCoroutine();
				SelectBestItemFromInventory();
				placePosition = targetEntrance.entrancePoint.position - ((Component)npcController.Npc).transform.position;
				float sqrMagnitude5 = ((Vector3)(ref placePosition)).sqrMagnitude;
				if (sqrMagnitude5 >= 1f)
				{
					placePosition = safePathPos - ((Component)npcController.Npc).transform.position;
					float sqrMagnitude6 = ((Vector3)(ref placePosition)).sqrMagnitude;
					if (sqrMagnitude6 >= 1f)
					{
						base.ai.SetDestinationToPositionLethalBotAI(safePathPos);
						if (!npcController.WaitForFullStamina && sqrMagnitude6 > 64f)
						{
							npcController.OrderToSprint();
						}
						else
						{
							npcController.OrderToStopSprint();
						}
						base.ai.OrderMoveToDestination();
					}
					else
					{
						base.ai.StopMoving();
						npcController.OrderToStopSprint();
					}
				}
				else if (!base.ai.AreHandsFree() && base.ai.HeldItem is CaveDwellerPhysicsProp)
				{
					LethalBotAI lethalBotAI3 = base.ai;
					placePosition = default(Vector3);
					lethalBotAI3.DropItem(placeObject: false, null, placePosition);
				}
				else
				{
					if (!(Time.timeSinceLevelLoad - base.ai.TimeSinceTeleporting > 1f))
					{
						return;
					}
					EntranceTeleport entrance = targetEntrance;
					Vector3? entranceTeleportPos = base.ai.GetTeleportPosOfEntrance(entrance);
					if (entranceTeleportPos.HasValue)
					{
						base.ai.StopMoving();
						if (base.LethalBotInteraction == null || base.LethalBotInteraction.IsCompleted)
						{
							base.LethalBotInteraction = new LethalBotInteraction(PatchesUtil.triggerScriptField.Invoke(entrance), delegate(LethalBotAI lethalBotAI, PlayerControllerB lethalBotController, InteractTrigger _)
							{
								//IL_0021: Unknown result type (might be due to invalid IL or missing references)
								Plugin.LogDebug("======== TeleportLethalBotAndSync " + lethalBotController.playerUsername + " !!!!!!!!!!!!!!! ");
								Vector3 value = entranceTeleportPos.Value;
								EntranceTeleport obj = entrance;
								lethalBotAI.SyncTeleportLethalBot(value, (obj != null) ? (!obj.isEntranceToBuilding) : (!((EnemyAI)lethalBotAI).isOutside), entrance);
							}, ignoreInteractablility: false, skipOriginalInteract: true);
						}
					}
					else
					{
						base.ai.State = new LostInFacilityState(this);
					}
				}
				return;
			}
			if (endIfOutside)
			{
				ChangeBackToPreviousState();
				return;
			}
			if ((Object)(object)targetShipTransform == (Object)null)
			{
				targetShipTransform = GetRandomInsideShipTransform();
			}
			Vector3? val7 = GetTargetShipPos();
			if (!val7.HasValue)
			{
				return;
			}
			if (!attemptedToUseTZP)
			{
				attemptedToUseTZP = true;
				if (base.ai.HasGrabbableObjectInInventory(typeof(TetraChemicalItem), out var _))
				{
					base.ai.State = new UseTZPInhalantState(this, GetDesiredDrunknessAmount());
					return;
				}
			}
			placePosition = val7.Value - ((Component)npcController.Npc).transform.position;
			float sqrMagnitude7 = ((Vector3)(ref placePosition)).sqrMagnitude;
			if (sqrMagnitude7 >= 4f)
			{
				StartSafePathCoroutine();
				SelectBestItemFromInventory();
				placePosition = safePathPos - ((Component)npcController.Npc).transform.position;
				float sqrMagnitude8 = ((Vector3)(ref placePosition)).sqrMagnitude;
				if (sqrMagnitude8 >= 1f)
				{
					base.ai.SetDestinationToPositionLethalBotAI(safePathPos);
					if ((!npcController.WaitForFullStamina && sqrMagnitude8 > 64f) || base.ai.AreWeExposed())
					{
						npcController.OrderToSprint();
					}
					else
					{
						npcController.OrderToStopSprint();
					}
					base.ai.OrderMoveToDestination();
				}
				else
				{
					base.ai.StopMoving();
					npcController.OrderToStopSprint();
				}
			}
			else
			{
				base.ai.State = new ChillAtShipState(this);
			}
		}

		protected override bool ShouldOnlyUseFrontEntrance()
		{
			return false;
		}

		public override void TryPlayCurrentStateVoiceAudio()
		{
			base.ai.LethalBotIdentity.Voice.TryPlayVoiceAudio(new PlayVoiceParameters
			{
				VoiceState = EnumVoicesState.FollowingPlayer,
				CanTalkIfOtherLethalBotTalk = false,
				WaitForCooldown = true,
				CutCurrentVoiceStateToTalk = false,
				CanRepeatVoiceState = true,
				ShouldSync = true,
				IsLethalBotInside = npcController.Npc.isInsideFactory,
				AllowSwearing = Plugin.Config.AllowSwearing.Value
			});
		}

		public new static void RegisterSignalTranslatorCommands()
		{
			SignalTranslatorCommandsManager.RegisterCommandForState<ReturnToShipState>(new SignalTranslatorCommand("return", delegate(AIState state, LethalBotAI lethalBotAI, string message)
			{
				ReturnToShipState returnToShipState = (ReturnToShipState)state;
				returnToShipState.endIfOutside = false;
				return true;
			}));
		}

		private float GetDesiredDrunknessAmount()
		{
			float num = ((npcController.Npc.movementSpeed > 0f) ? npcController.Npc.movementSpeed : 4.5f);
			float num2 = num / npcController.Npc.carryWeight;
			float num3 = Mathf.Clamp01(1f - num2 / num);
			float num4 = Mathf.Clamp01(num3 * 1.2f);
			if (num4 < 0.15f)
			{
				return 0f;
			}
			Plugin.LogDebug($"Bot {npcController.Npc.playerUsername}: BaseSpeed={num:F2}, EffectiveSpeed={num2:F2}, Drunkness={num4:F2}");
			return num4;
		}

		private Transform? GetRandomInsideShipTransform(bool allowFallback = true)
		{
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			List<Transform> list = StartOfRound.Instance.insideShipPositions.ToList();
			while (list.Count > 0)
			{
				int index = Random.Range(0, list.Count - 1);
				Transform val = list[index];
				list.RemoveAt(index);
				Vector3 navMeshPosition = RoundManager.Instance.GetNavMeshPosition(val.position, default(NavMeshHit), 2.7f, -1);
				if (base.ai.IsValidPathToTarget(navMeshPosition))
				{
					targetShipTransform = val;
					return val;
				}
			}
			if (!allowFallback)
			{
				return null;
			}
			Plugin.LogError("Bot " + npcController.Npc.playerUsername + " failed to find a valid position on the ship to return to! Falling back to middleOfShipNode");
			return StartOfRound.Instance.middleOfShipNode;
		}

		private Vector3? GetTargetShipPos()
		{
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)targetShipTransform == (Object)null)
			{
				return null;
			}
			if (Time.timeSinceLevelLoad - shipPositionUpdateTimer < 0.9f)
			{
				return targetShipPos;
			}
			Vector3 navMeshPosition = RoundManager.Instance.GetNavMeshPosition(targetShipTransform.position, default(NavMeshHit), 2.7f, -1);
			targetShipPos = navMeshPosition;
			shipPositionUpdateTimer = Time.timeSinceLevelLoad;
			return targetShipPos;
		}

		protected override Vector3? GetDesiredSafePathPosition()
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			if (((EnemyAI)base.ai).isOutside)
			{
				return GetTargetShipPos();
			}
			if (!((Object)(object)targetEntrance != (Object)null))
			{
				return null;
			}
			return targetEntrancePos;
		}

		protected override bool ShouldIgnoreInitialDangerCheck()
		{
			if (!((EnemyAI)base.ai).isOutside || LethalBotManager.IsShipCompromised(base.ai))
			{
				return base.ShouldIgnoreInitialDangerCheck();
			}
			if (!npcController.Npc.isInElevator)
			{
				return npcController.Npc.isInHangarShipRoom;
			}
			return true;
		}
	}
	public class SearchingForPlayerState : AIState
	{
		[CompilerGenerated]
		private sealed class <SearchingWander>d__11 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public SearchingForPlayerState <>4__this;

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

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

			[DebuggerHidden]
			public <SearchingWander>d__11(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_009a: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a4: Expected O, but got Unknown
				//IL_0063: Unknown result type (might be due to invalid IL or missing references)
				//IL_006d: Expected O, but got Unknown
				int num = <>1__state;
				SearchingForPlayerState searchingForPlayerState = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = null;
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					break;
				case 2:
				{
					<>1__state = -1;
					float num2 = Random.Range(1f, 3f);
					searchingForPlayerState.npcController.OrderToStopSprint();
					<>2__current = (object)new WaitForSeconds(num2);
					<>1__state = 3;
					return true;
				}
				case 3:
					<>1__state = -1;
					break;
				}
				if (searchingForPlayerState.ai.State != null && searchingForPlayerState.ai.State == searchingForPlayerState)
				{
					float num2 = Random.Range(1f, 3f);
					searchingForPlayerState.npcController.OrderToSprint();
					<>2__current = (object)new WaitForSeconds(num2);
					<>1__state = 2;
					return true;
				}
				return false;
			}

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

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

		private float lookForPlayerTimer;

		private Coroutine searchingWanderCoroutine;

		private bool foundSearchCenter;

		private LethalBotSearchRoutine searchForPlayers;

		public SearchingForPlayerState(AIState oldState)
			: base(oldState)
		{
			base.CurrentState = EnumAIStates.SearchingForPlayer;
			searchForPlayers = new LethalBotSearchRoutine(base.ai);
			searchForPlayers.searchCenterFollowsAI = false;
		}

		public SearchingForPlayerState(LethalBotAI ai)
			: base(ai)
		{
			base.CurrentState = EnumAIStates.SearchingForPlayer;
			searchForPlayers = new LethalBotSearchRoutine(ai);
			searchForPlayers.searchCenterFollowsAI = false;
		}

		public override void DoAI()
		{
			//IL_02bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0301: Unknown result type (might be due to invalid IL or missing references)
			StartSearchingWanderCoroutine();
			EnemyAI val = base.ai.CheckLOSForEnemy(90f, 40, 5);
			if ((Object)(object)val != (Object)null)
			{
				base.ai.State = new PanikState(this, val);
				return;
			}
			if (ShouldReturnToShip())
			{
				base.ai.State = new ReturnToShipState(this);
				return;
			}
			PlayerControllerB val2 = base.ai.LookingForPlayerToRevive();
			if ((Object)(object)val2 != (Object)null)
			{
				base.ai.State = new RescueAndReviveState(this, val2);
				return;
			}
			val2 = base.ai.LookingForPlayerToHeal();
			if ((Object)(object)val2 != (Object)null)
			{
				base.ai.State = new HealPlayerState(this, val2);
				return;
			}
			if (base.ai.HasSpaceInInventory())
			{
				GrabbableObject val3 = base.ai.LookingForObjectToGrab();
				if ((Object)(object)val3 != (Object)null)
				{
					base.ai.State = new FetchingObjectState(this, val3);
					return;
				}
				if (!base.ai.searchForScrap.visitInProgress && !((EnemyAI)base.ai).isOutside)
				{
					base.ai.searchForScrap.StartVisit();
				}
			}
			else if (base.ai.searchForScrap.visitInProgress)
			{
				base.ai.searchForScrap.StopSearch();
			}
			if (base.ai.HasScrapInInventory() && ((EnemyAI)base.ai).isOutside)
			{
				base.ai.State = new ReturnToShipState(this);
				return;
			}
			PlayerControllerB val4 = base.ai.CheckLOSForClosestPlayer(90f, 40, 5);
			if ((Object)(object)val4 != (Object)null)
			{
				base.ai.LethalBotIdentity.Voice.TryPlayVoiceAudio(new PlayVoiceParameters
				{
					VoiceState = EnumVoicesState.LostAndFound,
					CanTalkIfOtherLethalBotTalk = true,
					WaitForCooldown = false,
					CutCurrentVoiceStateToTalk = true,
					CanRepeatVoiceState = false,
					ShouldSync = true,
					IsLethalBotInside = npcController.Npc.isInsideFactory,
					AllowSwearing = Plugin.Config.AllowSwearing.Value
				});
				GroupManager.Instance.CreateOrJoinGroupWithMembersAndSync(val4, (PlayerControllerB[])(object)new PlayerControllerB[1] { npcController.Npc });
				base.ai.SyncAssignTargetAndSetMovingTo(val4);
				if (Plugin.Config.ChangeSuitAutoBehaviour.Value)
				{
					base.ai.ChangeSuitLethalBotServerRpc(npcController.Npc.playerClientId, val4.currentSuitID);
				}
			}
			else if (lookForPlayerTimer > 20f)
			{
				base.ai.State = new SearchingForScrapState(this);
			}
			else
			{
				lookForPlayerTimer += ((EnemyAI)base.ai).AIIntervalTime;
				Vector3? targetPosition = searchForPlayers.GetTargetPosition();
				if (targetPosition.HasValue)
				{
					base.ai.SetDestinationToPositionLethalBotAI(targetPosition.Value);
					base.ai.OrderMoveToDestination();
				}
				if (!foundSearchCenter && ((EnemyAI)base.ai).agent.isOnNavMesh)
				{
					searchForPlayers.searchCenter = ((Component)base.ai).transform.position;
					foundSearchCenter = true;
				}
				else if (!searchForPlayers.searchInProgress)
				{
					searchForPlayers.StartSearch();
				}
			}
		}

		public override void StopAllCoroutines()
		{
			base.StopAllCoroutines();
			searchForPlayers.StopSearch();
			StopSearchingWanderCoroutine();
		}

		public override void TryPlayCurrentStateVoiceAudio()
		{
			base.ai.LethalBotIdentity.Voice.TryPlayVoiceAudio(new PlayVoiceParameters
			{
				VoiceState = EnumVoicesState.Lost,
				CanTalkIfOtherLethalBotTalk = false,
				WaitForCooldown = true,
				CutCurrentVoiceStateToTalk = false,
				CanRepeatVoiceState = true,
				ShouldSync = true,
				IsLethalBotInside = npcController.Npc.isInsideFactory,
				AllowSwearing = Plugin.Config.AllowSwearing.Value
			});
		}

		public override void PlayerHeard(Vector3 noisePosition)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			targetLastKnownPosition = noisePosition;
			base.ai.LethalBotIdentity.Voice.TryPlayVoiceAudio(new PlayVoiceParameters
			{
				VoiceState = EnumVoicesState.HearsPlayer,
				CanTalkIfOtherLethalBotTalk = true,
				WaitForCooldown = false,
				CutCurrentVoiceStateToTalk = true,
				CanRepeatVoiceState = true,
				ShouldSync = true,
				IsLethalBotInside = npcController.Npc.isInsideFactory,
				AllowSwearing = Plugin.Config.AllowSwearing.Value
			});
			base.ai.State = new JustLostPlayerState(this);
		}

		public override string GetBillboardStateIndicator()
		{
			return "?";
		}

		[IteratorStateMachine(typeof(<SearchingWander>d__11))]
		private IEnumerator SearchingWander()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <SearchingWander>d__11(0)
			{
				<>4__this = this
			};
		}

		private void StartSearchingWanderCoroutine()
		{
			if (searchingWanderCoroutine == null)
			{
				searchingWanderCoroutine = ((MonoBehaviour)base.ai).StartCoroutine(SearchingWander());
			}
		}

		private void StopSearchingWanderCoroutine()
		{
			if (searchingWanderCoroutine != null)
			{
				((MonoBehaviour)base.ai).StopCoroutine(searchingWanderCoroutine);
			}
		}
	}
	public class SearchingForScrapState : AIState
	{
		[CompilerGenerated]
		private sealed class <SearchingWander>d__16 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public SearchingForScrapState <>4__this;

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

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

			[DebuggerHidden]
			public <SearchingWander>d__16(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_009a: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a4: Expected O, but got Unknown
				//IL_0063: Unknown result type (might be due to invalid IL or missing references)
				//IL_006d: Expected O, but got Unknown
				int num = <>1__state;
				SearchingForScrapState searchingForScrapState = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = null;
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					break;
				case 2:
				{
					<>1__state = -1;
					float num2 = Random.Range(1f, 3f);
					searchingForScrapState.npcController.OrderToStopSprint();
					<>2__current = (object)new WaitForSeconds(num2);
					<>1__state = 3;
					return true;
				}
				case 3:
					<>1__state = -1;
					break;
				}
				if (searchingForScrapState.ai.State != null && searchingForScrapState.ai.State == searchingForScrapState)
				{
					float num2 = Random.Range(1f, 3f);
					searchingForScrapState.npcController.OrderToSprint();
					<>2__current = (object)new WaitForSeconds(num2);
					<>1__state = 2;
					return true;
				}
				searchingForScrapState.searchingWanderCoroutine = null;
				return false;
			}

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

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

		private Coroutine? searchingWanderCoroutine;

		private bool grabbedLoadout;

		private bool formedGroup;

		private float scrapTimer;

		private float waitForSafePathTimer;

		private int entranceAttempts;

		public SearchingForScrapState(AIState oldState, EntranceTeleport? entranceToAvoid = null)
			: base(oldState)
		{
			base.CurrentState = EnumAIStates.SearchingForScrap;
			grabbedLoadout = false;
			formedGroup = false;
			entranceAttempts = 0;
			if ((Object)(object)entranceToAvoid != (Object)null)
			{
				targetEntrance = entranceToAvoid;
				waitForSafePathTimer = float.MaxValue;
			}
		}

		public SearchingForScrapState(LethalBotAI ai, EntranceTeleport? entranceToAvoid = null)
			: base(ai)
		{
			base.CurrentState = EnumAIStates.SearchingForScrap;
			grabbedLoadout = false;
			formedGroup = false;
			entranceAttempts = 0;
			if ((Object)(object)entranceToAvoid != (Object)null)
			{
				targetEntrance = entranceToAvoid;
				waitForSafePathTimer = float.MaxValue;
			}
		}

		public override void OnEnterState()
		{
			//IL_001f: 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)
			PlayerControllerB npc = npcController.Npc;
			if (!hasBeenStarted && LethalBotManager.Instance.LootTransferPlayers.Contains(NetworkBehaviourReference.op_Implicit((NetworkBehaviour)(object)npc)))
			{
				LethalBotManager.Instance.RemovePlayerFromLootTransferListAndSync(NetworkBehaviourReference.op_Implicit((NetworkBehaviour)(object)npc));
			}
			EntranceTeleport val = targetEntrance;
			EntranceTeleport entranceToAvoid = ((waitForSafePathTimer > 60f) ? val : null);
			targetEntrance = FindClosestEntrance(entranceToAvoid);
			entranceAttempts = (((Object)(object)targetEntrance == (Object)(object)val) ? entranceAttempts : 0);
			base.OnEnterState();
		}

		public override void DoAI()
		{
			//IL_011a: Unknown result type (might be due to invalid IL or missing references)
			//IL_012f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0134: Unknown result type (might be due to invalid IL or missing references)
			//IL_0148: Unknown result type (might be due to invalid IL or missing references)
			//IL_014d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0152: Unknown result type (might be due to invalid IL or missing references)
			//IL_0164: Unknown result type (might be due to invalid IL or missing references)
			//IL_0179: Unknown result type (might be due to invalid IL or missing references)
			//IL_017e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0192: Unknown result type (might be due to invalid IL or missing references)
			//IL_0197: Unknown result type (might be due to invalid IL or missing references)
			//IL_019c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0471: Unknown result type (might be due to invalid IL or missing references)
			//IL_0486: Unknown result type (might be due to invalid IL or missing references)
			//IL_048b: Unknown result type (might be due to invalid IL or missing references)
			//IL_049f: Unknown result type (might be due to invalid IL or missing references)
			//IL_04a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_04a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_04bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_04d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_04d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_04e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_04f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_03aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_03cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_0403: Unknown result type (might be due to invalid IL or missing references)
			//IL_0408: Unknown result type (might be due to invalid IL or missing references)
			//IL_040d: Unknown result type (might be due to invalid IL or missing references)
			//IL_05c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_05d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_05dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_05e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_076a: Unknown result type (might be due to invalid IL or missing references)
			//IL_077f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0784: Unknown result type (might be due to invalid IL or missing references)
			//IL_0789: Unknown result type (might be due to invalid IL or missing references)
			//IL_0ab8: Unknown result type (might be due to invalid IL or missing references)
			//IL_07a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_07b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_07bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_07c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_064c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0652: Unknown result type (might be due to invalid IL or missing references)
			//IL_07fd: Unknown result type (might be due to invalid IL or missing references)
			if (LethalBotManager.AreWeAtTheCompanyBuilding())
			{
				base.ai.State = new CollectScrapToSellState(this);
				return;
			}
			StartOfRound instance = StartOfRound.Instance;
			if ((npcController.Npc.isInElevator || npcController.Npc.isInHangarShipRoom) && !LethalBotManager.AreWeInOrbit(instance) && (LethalBotManager.IsTheShipLeaving(instance) || !LethalBotManager.IsTheShipLanded(instance)))
			{
				return;
			}
			if (LethalBotManager.AreWeInOrbit(instance))
			{
				base.ai.State = new ReturnToShipState(this);
				return;
			}
			if (!grabbedLoadout)
			{
				grabbedLoadout = true;
				base.ai.State = new GrabLoadoutState(this);
				return;
			}
			Vector3 placePosition;
			if (!formedGroup)
			{
				formedGroup = true;
				int groupID = base.ai.LethalBotIdentity.GroupID;
				if (groupID != -1 && !GroupManager.Instance.IsPlayerInGroup(npcController.Npc))
				{
					if (GroupManager.Instance.DoesInternalGroupExist(base.ai, out var groupID2))
					{
						PlayerControllerB groupLeader = GroupManager.Instance.GetGroupLeader(groupID2);
						if ((Object)(object)groupLeader != (Object)null)
						{
							placePosition = Vector3.Scale(((Component)groupLeader).transform.position - ((Component)npcController.Npc).transform.position, new Vector3(1f, 0f, 1f));
							float sqrMagnitude = ((Vector3)(ref placePosition)).sqrMagnitude;
							placePosition = Vector3.Scale(((Component)groupLeader).transform.position - ((Component)npcController.Npc).transform.position, new Vector3(0f, 1f, 0f));
							float sqrMagnitude2 = ((Vector3)(ref placePosition)).sqrMagnitude;
							if (sqrMagnitude < 625f && sqrMagnitude2 < 2500f)
							{
								GroupManager.Instance.CreateOrJoinGroupAndSync(npcController.Npc);
							}
						}
					}
					else
					{
						GroupManager.Instance.CreateOrJoinGroupAndSync(npcController.Npc);
					}
					return;
				}
			}
			StartSearchingWanderCoroutine();
			StartLookingAroundCoroutine();
			EnemyAI val = base.ai.CheckLOSForEnemy(90f, 40, 5);
			if ((Object)(object)val != (Object)null)
			{
				base.ai.State = new PanikState(this, val);
				return;
			}
			if (ShouldReturnToShip())
			{
				base.ai.State = new ReturnToShipState(this);
				return;
			}
			PlayerControllerB val2 = base.ai.LookingForPlayerToRevive();
			if ((Object)(object)val2 != (Object)null)
			{
				base.ai.State = new RescueAndReviveState(this, val2);
				return;
			}
			val2 = base.ai.LookingForPlayerToHeal();
			if ((Object)(object)val2 != (Object)null)
			{
				base.ai.State = new HealPlayerState(this, val2);
				return;
			}
			int groupId = GroupManager.Instance.GetGroupId(npcController.Npc);
			if (!IsInventoryFull(groupId))
			{
				GrabbableObject val3 = base.ai.LookingForObjectToGrab();
				if ((Object)(object)val3 != (Object)null && base.ai.HasSpaceInInventory(val3))
				{
					scrapTimer = 0f;
					base.ai.State = new FetchingObjectState(this, val3);
					return;
				}
				SelectBestItemFromInventory();
				if (groupId != -1)
				{
					PlayerControllerB groupLeader2 = GroupManager.Instance.GetGroupLeader(groupId);
					if ((Object)(object)groupLeader2 == (Object)(object)npcController.Npc)
					{
						PlayerControllerB furthestMemberFromCenter = GroupManager.Instance.GetFurthestMemberFromCenter(groupId);
						if ((Object)(object)furthestMemberFromCenter != (Object)null && !base.ai.AreWeExposed())
						{
							Vector3 groupCenter = GroupManager.Instance.GetGroupCenter(groupLeader2, groupId);
							placePosition = Vector3.Scale(groupCenter - ((Component)furthestMemberFromCenter).transform.position, new Vector3(1f, 0f, 1f));
							float sqrMagnitude3 = ((Vector3)(ref placePosition)).sqrMagnitude;
							placePosition = Vector3.Scale(groupCenter - ((Component)furthestMemberFromCenter).transform.position, new Vector3(0f, 1f, 0f));
							float sqrMagnitude4 = ((Vector3)(ref placePosition)).sqrMagnitude;
							if (sqrMagnitude3 > 156.25f || sqrMagnitude4 > 625f)
							{
								if (base.ai.searchForScrap.searchInProgress)
								{
									base.ai.searchForScrap.StopSearch();
								}
								base.ai.StopMoving();
								return;
							}
						}
					}
					else if ((Object)(object)groupLeader2 != (Object)null)
					{
						placePosition = Vector3.Scale(((Component)groupLeader2).transform.position - ((Component)npcController.Npc).transform.position, new Vector3(1f, 0f, 1f));
						float sqrMagnitude5 = ((Vector3)(ref placePosition)).sqrMagnitude;
						placePosition = Vector3.Scale(((Component)groupLeader2).transform.position - ((Component)npcController.Npc).transform.position, new Vector3(0f, 1f, 0f));
						float sqrMagnitude6 = ((Vector3)(ref placePosition)).sqrMagnitude;
						if (sqrMagnitude5 < 625f && sqrMagnitude6 < 2500f)
						{
							base.ai.State = new GetCloseToPlayerState(this, groupLeader2);
							return;
						}
						GroupManager.Instance.RemoveFromCurrentGroupAndSync(npcController.Npc);
					}
					else
					{
						GroupManager.Instance.RemoveFromCurrentGroupAndSync(npcController.Npc);
					}
				}
				if (((EnemyAI)base.ai).isOutside)
				{
					if (base.ai.HasScrapInInventory() || (groupId != -1 && GroupManager.Instance.DoesGroupHaveScrap(groupId)))
					{
						bool flag = true;
						if (LethalBotManager.Instance.LootTransferPlayers.Count > 0)
						{
							bool flag2 = false;
							EntranceTeleport[] entrancesTeleportArray = LethalBotAI.EntrancesTeleportArray;
							foreach (EntranceTeleport val4 in entrancesTeleportArray)
							{
								if (val4.isEntranceToBuilding)
								{
									placePosition = val4.entrancePoint.position - ((Component)npcController.Npc).transform.position;
									if (((Vector3)(ref placePosition)).sqrMagnitude < 400f)
									{
										flag2 = true;
										break;
									}
								}
							}
							if (flag2)
							{
								base.ai.StopMoving();
								npcController.OrderToStopSprint();
								GrabbableObject heldItem = base.ai.HeldItem;
								int objectSlot;
								if ((Object)(object)heldItem != (Object)null && FindObject(heldItem))
								{
									LethalBotAI lethalBotAI2 = base.ai;
									placePosition = default(Vector3);
									lethalBotAI2.DropItem(placeObject: false, null, placePosition);
									LethalBotAI.DictJustDroppedItems.Remove(heldItem);
									flag = false;
								}
								else if (base.ai.HasGrabbableObjectInInventory((Func<GrabbableObject, bool>)FindObject, out objectSlot))
								{
									base.ai.SwitchItemSlotsAndSync(objectSlot);
									flag = false;
								}
							}
						}
						if (flag)
						{
							base.ai.State = new ReturnToShipState(this);
						}
						return;
					}
					if ((Object)(object)targetEntrance == (Object)null || waitForSafePathTimer > 60f || (entranceAttempts > 3 && (base.LethalBotInteraction == null || base.LethalBotInteraction.IsCompleted)))
					{
						EntranceTeleport entranceToAvoid = ((waitForSafePathTimer > 60f || entranceAttempts > 3) ? targetEntrance : null);
						targetEntrance = FindClosestEntrance(entranceToAvoid);
						waitForSafePathTimer = 0f;
						entranceAttempts = 0;
						if ((Object)(object)targetEntrance == (Object)null)
						{
							base.ai.State = new ReturnToShipState(this);
							return;
						}
					}
					StartSafePathCoroutine();
					placePosition = targetEntrance.entrancePoint.position - ((Component)npcController.Npc).transform.position;
					float sqrMagnitude7 = ((Vector3)(ref placePosition)).sqrMagnitude;
					if (sqrMagnitude7 >= 1f)
					{
						placePosition = safePathPos - ((Component)npcController.Npc).transform.position;
						float sqrMagnitude8 = ((Vector3)(ref placePosition)).sqrMagnitude;
						if (sqrMagnitude8 >= 1f)
						{
							waitForSafePathTimer = Mathf.Max(waitForSafePathTimer - ((EnemyAI)base.ai).AIIntervalTime, 0f);
							base.ai.SetDestinationToPositionLethalBotAI(safePathPos);
							base.ai.OrderMoveToDestination();
						}
						else
						{
							waitForSafePathTimer += ((EnemyAI)base.ai).AIIntervalTime;
							base.ai.StopMoving();
							npcController.OrderToStopSprint();
						}
					}
					else
					{
						if (!(Time.timeSinceLevelLoad - base.ai.TimeSinceTeleporting > 1f))
						{
							return;
						}
						EntranceTeleport entrance = targetEntrance;
						Vector3? entranceTeleportPos = base.ai.GetTeleportPosOfEntrance(entrance);
						if (entranceTeleportPos.HasValue)
						{
							base.ai.StopMoving();
							if (!IsEntranceSafe(entrance))
							{
								waitForSafePathTimer += ((EnemyAI)base.ai).AIIntervalTime;
							}
							else if (base.LethalBotInteraction == null || base.LethalBotInteraction.IsCompleted)
							{
								base.LethalBotInteraction = new LethalBotInteraction(PatchesUtil.triggerScriptField.Invoke(entrance), delegate(LethalBotAI lethalBotAI, PlayerControllerB lethalBotController, InteractTrigger _)
								{
									//IL_0021: Unknown result type (might be due to invalid IL or missing references)
									Plugin.LogDebug("======== TeleportLethalBotAndSync " + lethalBotController.playerUsername + " !!!!!!!!!!!!!!! ");
									Vector3 value = entranceTeleportPos.Value;
									EntranceTeleport obj = entrance;
									lethalBotAI.SyncTeleportLethalBot(value, (obj != null) ? (!obj.isEntranceToBuilding) : (!((EnemyAI)lethalBotAI).isOutside), entrance);
								}, ignoreInteractablility: false, skipOriginalInteract: true);
								entranceAttempts++;
							}
						}
						else
						{
							base.ai.State = new ReturnToShipState(this);
						}
					}
					return;
				}
				StopSafePathCoroutine();
				if (base.ai.HasScrapInInventory())
				{
					if (scrapTimer > 60f)
					{
						bool flag3 = true;
						if (LethalBotManager.Instance.LootTransferPlayers.Count > 0)
						{
							flag3 = false;
						}
						base.ai.State = new ReturnToShipState(this, !flag3);
						return;
					}
					scrapTimer += ((EnemyAI)base.ai).AIIntervalTime;
				}
				else
				{
					scrapTimer = 0f;
				}
				MineshaftElevatorController elevatorScript = LethalBotAI.ElevatorScript;
				if ((Object)(object)elevatorScript != (Object)null && (base.ai.IsInElevatorStartRoom || ((!elevatorScript.elevatorFinishedMoving || !elevatorScript.elevatorDoorOpen) && base.ai.IsInsideElevator)))
				{
					if (base.ai.searchForScrap.searchInProgress)
					{
						base.ai.searchForScrap.StopSearch();
					}
					base.ai.UseElevator(goUp: false);
					return;
				}
				if (LethalBotManager.IsThereATrappedPlayer)
				{
					DoorLock val5 = base.ai.UnlockDoorIfNeeded(200f);
					if ((Object)(object)val5 != (Object)null)
					{
						base.ai.State = new UseKeyOnLockedDoorState(this, val5);
						return;
					}
				}
				else
				{
					DoorLock val6 = base.ai.UnlockDoorIfNeeded(15f, checkLineOfSight: true, 4f);
					if ((Object)(object)val6 != (Object)null)
					{
						base.ai.State = new UseKeyOnLockedDoorState(this, val6);
						return;
					}
				}
				Vector3? targetPosition = base.ai.searchForScrap.GetTargetPosition();
				if (targetPosition.HasValue)
				{
					base.ai.SetDestinationToPositionLethalBotAI(targetPosition.Value);
					base.ai.OrderMoveToDestination();
				}
				if (!base.ai.searchForScrap.searchInProgress)
				{
					base.ai.searchForScrap.StartSearch();
				}
			}
			else
			{
				bool flag4 = true;
				if (!((EnemyAI)base.ai).isOutside && LethalBotManager.Instance.LootTransferPlayers.Count > 0)
				{
					flag4 = false;
				}
				base.ai.State = new ReturnToShipState(this, !flag4);
			}
		}

		public override void StopAllCoroutines()
		{
			base.StopAllCoroutines();
			StopSearchingWanderCoroutine();
		}

		public override void TryPlayCurrentStateVoiceAudio()
		{
			base.ai.LethalBotIdentity.Voice.TryPlayVoiceAudio(new PlayVoiceParameters
			{
				VoiceState = EnumVoicesState.FollowingPlayer,
				CanTalkIfOtherLethalBotTalk = false,
				WaitForCooldown = true,
				CutCurrentVoiceStateToTalk = false,
				CanRepeatVoiceState = true,
				ShouldSync = true,
				IsLethalBotInside = npcController.Npc.isInsideFactory,
				AllowSwearing = Plugin.Config.AllowSwearing.Value
			});
		}

		protected override bool FindObject(GrabbableObject item)
		{
			if (LethalBotAI.IsItemScrap(item))
			{
				int objectSlot;
				if (base.ai.IsGrabbableObjectInLoadout(item))
				{
					return base.ai.HasDuplicateLoadoutItems(item, out objectSlot);
				}
				return true;
			}
			return false;
		}

		protected override Vector3? GetDesiredSafePathPosition()
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)targetEntrance == (Object)null || !((EnemyAI)base.ai).isOutside)
			{
				return null;
			}
			return targetEntrance.entrancePoint.position;
		}

		protected override bool ShouldIgnoreInitialDangerCheck()
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)targetEntrance != (Object)null)
			{
				Vector3 val = targetEntrance.entrancePoint.position - ((Component)npcController.Npc).transform.position;
				float sqrMagnitude = ((Vector3)(ref val)).sqrMagnitude;
				return sqrMagnitude < 400f;
			}
			return base.ShouldIgnoreInitialDangerCheck();
		}

		private bool IsInventoryFull(int? groupID)
		{
			int valueOrDefault = groupID.GetValueOrDefault();
			if (!groupID.HasValue)
			{
				valueOrDefault = GroupManager.Instance.GetGroupId(npcController.Npc);
				groupID = valueOrDefault;
			}
			if (groupID.GetValueOrDefault() != -1)
			{
				List<PlayerControllerB> groupMembers = GroupManager.Instance.GetGroupMembers(groupID.Value);
				GrabbableObject[] array = null;
				foreach (PlayerControllerB item in groupMembers)
				{
					if ((Object)(object)item == (Object)null)
					{
						continue;
					}
					array = item.ItemSlots;
					int inventorySize = LethalBotAI.GetInventorySize(item, array);
					for (int i = 0; i < inventorySize; i++)
					{
						if ((Object)(object)array[i] == (Object)null)
						{
							return false;
						}
					}
				}
				return true;
			}
			return !base.ai.HasSpaceInInventory();
		}

		[IteratorStateMachine(typeof(<SearchingWander>d__16))]
		private IEnumerator SearchingWander()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <SearchingWander>d__16(0)
			{
				<>4__this = this
			};
		}

		private void StartSearchingWanderCoroutine()
		{
			if (searchingWanderCoroutine == null)
			{
				searchingWanderCoroutine = ((MonoBehaviour)base.ai).StartCoroutine(SearchingWander());
			}
		}

		private void StopSearchingWanderCoroutine()
		{
			if (searchingWanderCoroutine != null)
			{
				((MonoBehaviour)base.ai).StopCoroutine(searchingWanderCoroutine);
				searchingWanderCoroutine = null;
			}
		}
	}
	public class SellScrapState : AIState
	{
		private static InteractTrigger? bellInteractTrigger;

		public SellScrapState(AIState oldState)
			: base(oldState)
		{
			base.CurrentState = EnumAIStates.SellScrap;
		}

		public override void OnEnterState()
		{
			if (!hasBeenStarted)
			{
				if ((Object)(object)LethalBotManager.CompanyDesk == (Object)null || !LethalBotManager.AreWeAtTheCompanyBuilding())
				{
					base.ai.State = new ReturnToShipState(this);
					return;
				}
				if ((Object)(object)bellInteractTrigger == (Object)null)
				{
					GameObject val = GameObject.Find("BellDinger");
					if ((Object)(object)val != (Object)null)
					{
						Transform obj = val.transform.Find("Trigger");
						bellInteractTrigger = ((obj != null) ? ((Component)obj).GetComponent<InteractTrigger>() : null);
						if ((Object)(object)bellInteractTrigger == (Object)null)
						{
							Plugin.LogWarning("Could not find the bell interact trigger! The bell sounds will be faked!");
						}
						else
						{
							Plugin.LogInfo($"Found bell interact trigger {bellInteractTrigger}!");
						}
					}
				}
			}
			base.OnEnterState();
		}

		public override void DoAI()
		{
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0180: Unknown result type (might be due to invalid IL or missing references)
			//IL_013a: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ba: Unknown result type (might be due to invalid IL or missing references)
			DepositItemsDesk companyDesk = LethalBotManager.CompanyDesk;
			if ((Object)(object)companyDesk == (Object)null || !LethalBotManager.AreWeAtTheCompanyBuilding() || companyDesk.attacking)
			{
				base.ai.State = new ReturnToShipState(this);
				return;
			}
			Vector3 navMeshPosition = RoundManager.Instance.GetNavMeshPosition(((Collider)companyDesk.triggerCollider).ClosestPoint(((Component)npcController.Npc).transform.position), default(NavMeshHit), 20f, -1);
			if (!RoundManager.Instance.GotNavMeshPositionResult)
			{
				base.ai.State = new ReturnToShipState(this);
				return;
			}
			bool flag = false;
			bool flag2 = true;
			bool flag3 = LethalBotManager.HaveWeFulfilledTheProfitQuota();
			if (companyDesk.inGrabbingObjectsAnimation || companyDesk.doorOpen)
			{
				flag = true;
			}
			Vector3 placePosition = navMeshPosition - ((Component)npcController.Npc).transform.position;
			float sqrMagnitude = ((Vector3)(ref placePosition)).sqrMagnitude;
			if (!flag && (LethalBotManager.GetNumberOfItemsOnDesk() >= 150 || ((Object)(object)base.ai.LookingForObjectsToSell(ignoreHeldFlag: true) == (Object)null && LethalBotManager.AreThereItemsOnDesk())))
			{
				flag2 = false;
				if (sqrMagnitude <= 9f)
				{
					base.ai.StopMoving();
					if ((Object)(object)bellInteractTrigger != (Object)null)
					{
						npcController.OrderToLookAtPosition(((Component)bellInteractTrigger).transform.position, EnumLookAtPriority.HIGH_PRIORITY);
						bellInteractTrigger.Interact(npcController.Npc.thisPlayerBody);
					}
					else
					{
						RoundManager.Instance.PlayAudibleNoise(((Component)npcController.Npc).transform.position, 10f, 0.5f, 0, false, 0);
					}
					return;
				}
			}
			if (!flag && flag2 && (flag3 || !base.ai.HasSellableItemInInventory()))
			{
				base.ai.State = new ReturnToShipState(this);
				return;
			}
			if (sqrMagnitude > 9f)
			{
				base.ai.SetDestinationToPositionLethalBotAI(navMeshPosition);
				if (!npcController.WaitForFullStamina && sqrMagnitude > 64f)
				{
					npcController.OrderToSprint();
				}
				else if (npcController.WaitForFullStamina || sqrMagnitude < 49f)
				{
					npcController.OrderToStopSprint();
				}
				if (flag && sqrMagnitude <= 100f)
				{
					base.ai.StopMoving();
				}
				else
				{
					base.ai.OrderMoveToDestination();
				}
				return;
			}
			base.ai.StopMoving();
			if (!(flag || flag3))
			{
				int objectSlot;
				if (!base.ai.AreHandsFree() && FindObject(base.ai.HeldItem))
				{
					companyDesk.PlaceItemOnCounter(npcController.Npc);
				}
				else if (!base.ai.AreHandsFree() && base.ai.HeldItem.itemProperties.twoHanded)
				{
					LethalBotAI lethalBotAI = base.ai;
					placePosition = default(Vector3);
					lethalBotAI.DropItem(placeObject: false, null, placePosition);
				}
				else if (base.ai.HasGrabbableObjectInInventory((Func<GrabbableObject, bool>)FindObject, out objectSlot))
				{
					base.ai.SwitchItemSlotsAndSync(objectSlot);
				}
			}
		}

		public override void TryPlayCurrentStateVoiceAudio()
		{
		}

		protected override bool FindObject(GrabbableObject item)
		{
			return base.ai.IsGrabbableObjectSellable(item, ignoreHeldFlag: true, skipPathCheck: true);
		}
	}
	public class TransferLootState : AIState
	{
		private float waitTimer;

		private HashSet<EntranceTeleport> checkedEntrances = new HashSet<EntranceTeleport>();

		public TransferLootState(AIState oldState)
			: base(oldState)
		{
			base.CurrentState = EnumAIStates.TransferLoot;
			checkedEntrances.Clear();
		}

		public TransferLootState(LethalBotAI ai)
			: base(ai)
		{
			base.CurrentState = EnumAIStates.TransferLoot;
			checkedEntrances.Clear();
		}

		public override void OnEnterState()
		{
			//IL_0030: 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_0072: 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)
			if (!hasBeenStarted)
			{
				if (LethalBotManager.AreWeAtTheCompanyBuilding() || LethalBotManager.AreWeInOrbit())
				{
					if (LethalBotManager.Instance.LootTransferPlayers.Contains(NetworkBehaviourReference.op_Implicit((NetworkBehaviour)(object)npcController.Npc)))
					{
						LethalBotManager.Instance.RemovePlayerFromLootTransferListAndSync(NetworkBehaviourReference.op_Implicit((NetworkBehaviour)(object)npcController.Npc));
					}
					ChangeBackToPreviousState();
					return;
				}
				if (!LethalBotManager.Instance.LootTransferPlayers.Contains(NetworkBehaviourReference.op_Implicit((NetworkBehaviour)(object)npcController.Npc)))
				{
					LethalBotManager.Instance.AddPlayerToLootTransferListAndSync(NetworkBehaviourReference.op_Implicit((NetworkBehaviour)(object)npcController.Npc));
				}
			}
			HashSet<EntranceTeleport> entrancesToAvoid = checkedEntrances;
			targetEntrance = FindClosestEntrance(null, entrancesToAvoid);
			waitTimer = 0f;
			base.OnEnterState();
		}

		public override void DoAI()
		{
			//IL_0048: 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)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_020d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0212: Unknown result type (might be due to invalid IL or missing references)
			//IL_0217: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0230: Unknown result type (might be due to invalid IL or missing references)
			EnemyAI val = base.ai.CheckLOSForEnemy(90f, 40, 5);
			if ((Object)(object)val != (Object)null)
			{
				base.ai.State = new PanikState(this, val);
				return;
			}
			if (ShouldReturnToShip())
			{
				LethalBotManager.Instance.RemovePlayerFromLootTransferListAndSync(NetworkBehaviourReference.op_Implicit((NetworkBehaviour)(object)npcController.Npc));
				base.ai.State = new ReturnToShipState(this);
				return;
			}
			if (LethalBotManager.AreWeAtTheCompanyBuilding() || LethalBotManager.AreWeInOrbit())
			{
				if (LethalBotManager.Instance.LootTransferPlayers.Contains(NetworkBehaviourReference.op_Implicit((NetworkBehaviour)(object)npcController.Npc)))
				{
					LethalBotManager.Instance.RemovePlayerFromLootTransferListAndSync(NetworkBehaviourReference.op_Implicit((NetworkBehaviour)(object)npcController.Npc));
				}
				ChangeBackToPreviousState();
				return;
			}
			PlayerControllerB val2 = base.ai.LookingForPlayerToRevive();
			if ((Object)(object)val2 != (Object)null)
			{
				base.ai.State = new RescueAndReviveState(this, val2);
				return;
			}
			val2 = base.ai.LookingForPlayerToHeal();
			if ((Object)(object)val2 != (Object)null)
			{
				base.ai.State = new HealPlayerState(this, val2);
			}
			else if (base.ai.HasSpaceInInventory())
			{
				GrabbableObject val3 = base.ai.LookingForObjectToGrab();
				if ((Object)(object)val3 != (Object)null)
				{
					base.ai.State = new FetchingObjectState(this, val3);
					return;
				}
				if (!((EnemyAI)base.ai).isOutside)
				{
					base.ai.State = new ReturnToShipState(this, endIfOutside: true);
					return;
				}
				if ((Object)(object)targetEntrance == (Object)null || !targetEntrance.isEntranceToBuilding)
				{
					checkedEntrances.Clear();
					targetEntrance = FindClosestEntrance();
					if ((Object)(object)targetEntrance == (Object)null || !targetEntrance.isEntranceToBuilding)
					{
						base.ai.State = new ReturnToShipState(this);
						return;
					}
				}
				StartSafePathCoroutine();
				StartLookingAroundCoroutine();
				SelectBestItemFromInventory();
				Vector3 val4 = safePathPos - ((Component)npcController.Npc).transform.position;
				float sqrMagnitude = ((Vector3)(ref val4)).sqrMagnitude;
				if (sqrMagnitude >= 1f)
				{
					base.ai.SetDestinationToPositionLethalBotAI(safePathPos);
					if (!npcController.WaitForFullStamina && sqrMagnitude > 64f)
					{
						npcController.OrderToSprint();
					}
					else
					{
						npcController.OrderToStopSprint();
					}
					base.ai.OrderMoveToDestination();
					waitTimer = Mathf.Max(waitTimer - ((EnemyAI)base.ai).AIIntervalTime, 0f);
					return;
				}
				base.ai.StopMoving();
				npcController.OrderToStopSprint();
				val4 = targetEntrance.entrancePoint.position - ((Component)npcController.Npc).transform.position;
				float sqrMagnitude2 = ((Vector3)(ref val4)).sqrMagnitude;
				if (sqrMagnitude2 <= 1f)
				{
					waitTimer += ((EnemyAI)base.ai).AIIntervalTime;
					if (!(waitTimer >= 30f))
					{
						return;
					}
					waitTimer = 0f;
					EntranceTeleport val5 = targetEntrance;
					checkedEntrances.Add(val5);
					if (base.ai.HasScrapInInventory())
					{
						base.ai.State = new ReturnToShipState(this);
						return;
					}
					HashSet<EntranceTeleport> entrancesToAvoid = checkedEntrances;
					targetEntrance = FindClosestEntrance(null, entrancesToAvoid);
					if (!((Object)(object)targetEntrance != (Object)null) || checkedEntrances.Contains(targetEntrance) || !((Object)(object)val5 != (Object)(object)targetEntrance))
					{
						targetEntrance = null;
						checkedEntrances.Clear();
						checkedEntrances.Add(val5);
					}
				}
				else
				{
					waitTimer = Mathf.Max(waitTimer - ((EnemyAI)base.ai).AIIntervalTime, 0f);
				}
			}
			else
			{
				base.ai.State = new ReturnToShipState(this);
			}
		}

		public override void TryPlayCurrentStateVoiceAudio()
		{
			base.ai.LethalBotIdentity.Voice.TryPlayVoiceAudio(new PlayVoiceParameters
			{
				VoiceState = EnumVoicesState.FollowingPlayer,
				CanTalkIfOtherLethalBotTalk = false,
				WaitForCooldown = true,
				CutCurrentVoiceStateToTalk = false,
				CanRepeatVoiceState = true,
				ShouldSync = true,
				IsLethalBotInside = npcController.Npc.isInsideFactory,
				AllowSwearing = Plugin.Config.AllowSwearing.Value
			});
		}

		public new static void RegisterChatCommands()
		{
			ChatCommandsManager.RegisterCommandForState<TransferLootState>(new ChatCommand("transfer loot", (AIState state, LethalBotAI lethalBotAI, PlayerControllerB playerWhoSentMessage, string message, bool isVoice) => true));
		}

		protected override Vector3? GetDesiredSafePathPosition()
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)targetEntrance == (Object)null || !((EnemyAI)base.ai).isOutside)
			{
				return null;
			}
			return targetEntrance.entrancePoint.position;
		}
	}
	public class UseInverseTeleporterState : AIState
	{
		public UseInverseTeleporterState(AIState oldState)
			: base(oldState)
		{
			base.CurrentState = EnumAIStates.UseInverseTeleport;
		}

		public UseInverseTeleporterState(LethalBotAI ai)
			: base(ai)
		{
			base.CurrentState = EnumAIStates.UseInverseTeleport;
		}

		public override void DoAI()
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)LethalBotAI.InverseTeleporter == (Object)null || !LethalBotManager.IsInverseTeleporterActive)
			{
				TimeOfDay instance = TimeOfDay.Instance;
				if ((Object)(object)instance != (Object)null)
				{
					DayMode dayPhase = instance.GetDayPhase(instance.currentDayTime / instance.totalTime);
					if ((int)dayPhase == 0)
					{
						((EnemyAI)base.ai).targetPlayer = null;
						base.ai.State = new SearchingForScrapState(this);
						return;
					}
				}
				base.ai.State = new ReturnToShipState(this);
			}
			else
			{
				Vector3 val = LethalBotAI.InverseTeleporter.teleportOutPosition.position - ((Component)npcController.Npc).transform.position;
				float sqrMagnitude = ((Vector3)(ref val)).sqrMagnitude;
				if (sqrMagnitude >= 2.25f)
				{
					npcController.OrderToSprint();
					base.ai.SetDestinationToPositionLethalBotAI(LethalBotAI.InverseTeleporter.teleportOutPosition.position);
					base.ai.OrderMoveToDestination();
				}
				else
				{
					base.ai.StopMoving();
				}
			}
		}

		public override void TryPlayCurrentStateVoiceAudio()
		{
		}
	}
	public class UseKeyOnLockedDoorState : AIState
	{
		private DoorLock? targetDoor;

		private Vector3? doorPos;

		private float attemptToUnlockTimer;

		private GrabbableObject? droppedHeldItem;

		private bool placedLockpicker;

		public UseKeyOnLockedDoorState(AIState oldState, DoorLock? doorLock)
			: base(oldState)
		{
			base.CurrentState = EnumAIStates.UseKeyOnLockedDoor;
			targetDoor = doorLock;
		}

		public override void OnEnterState()
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			if (!hasBeenStarted && (Object)(object)targetDoor != (Object)null)
			{
				Vector3? val = LethalBotAI.GetOffsetLockPickerPosition(targetDoor);
				Vector3? val2 = LethalBotAI.GetOffsetLockPickerPosition(targetDoor, checkBack: true);
				float? num = null;
				float? num2 = null;
				if (val.HasValue && base.ai.IsValidPathToTarget(val.Value, calculatePathDistance: true))
				{
					num = ((EnemyAI)base.ai).pathDistance;
				}
				if (val2.HasValue && base.ai.IsValidPathToTarget(val2.Value, calculatePathDistance: true))
				{
					num2 = ((EnemyAI)base.ai).pathDistance;
				}
				if (num.HasValue && num2.HasValue)
				{
					doorPos = ((num.Value <= num2.Value) ? val : val2);
				}
				else if (num.HasValue)
				{
					doorPos = val;
				}
				else if (num2.HasValue)
				{
					doorPos = val2;
				}
				else
				{
					targetDoor = null;
				}
			}
			base.OnEnterState();
		}

		public override void OnExitState(AIState newState)
		{
			if ((Object)(object)droppedHeldItem != (Object)null)
			{
				LethalBotAI.DictJustDroppedItems.Remove(droppedHeldItem);
			}
			base.OnExitState(newState);
		}

		public override void DoAI()
		{
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_014f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0257: Unknown result type (might be due to invalid IL or missing references)
			//IL_025c: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_027f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0284: Unknown result type (might be due to invalid IL or missing references)
			//IL_0302: Unknown result type (might be due to invalid IL or missing references)
			//IL_0317: Unknown result type (might be due to invalid IL or missing references)
			//IL_031c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0321: Unknown result type (might be due to invalid IL or missing references)
			//IL_04db: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0469: Unknown result type (might be due to invalid IL or missing references)
			EnemyAI val = base.ai.CheckLOSForEnemy(90f, 40, 5);
			if ((Object)(object)val != (Object)null)
			{
				base.ai.State = new PanikState(this, val);
				return;
			}
			if ((Object)(object)targetDoor == (Object)null || !targetDoor.isLocked || targetDoor.isPickingLock)
			{
				if (placedLockpicker && (Object)(object)targetDoor != (Object)null && targetDoor.isPickingLock)
				{
					SelectBestItemFromInventory();
					StartLookingAroundCoroutine();
				}
				else
				{
					ChangeBackToPreviousState();
				}
				return;
			}
			if (!doorPos.HasValue || !base.ai.IsValidPathToTarget(doorPos.Value))
			{
				Vector3? val2 = LethalBotAI.GetOffsetLockPickerPosition(targetDoor);
				Vector3? val3 = LethalBotAI.GetOffsetLockPickerPosition(targetDoor, checkBack: true);
				float? num = null;
				float? num2 = null;
				if (val2.HasValue && base.ai.IsValidPathToTarget(val2.Value, calculatePathDistance: true))
				{
					num = ((EnemyAI)base.ai).pathDistance;
				}
				if (val3.HasValue && base.ai.IsValidPathToTarget(val3.Value, calculatePathDistance: true))
				{
					num2 = ((EnemyAI)base.ai).pathDistance;
				}
				if (num.HasValue && num2.HasValue)
				{
					doorPos = ((num.Value <= num2.Value) ? val2 : val3);
				}
				else if (num.HasValue)
				{
					doorPos = val2;
				}
				else
				{
					if (!num2.HasValue)
					{
						targetDoor = null;
						return;
					}
					doorPos = val3;
				}
			}
			int objectSlot = (base.ai.IsHoldingKey() ? npcController.Npc.currentItemSlot : (-1));
			if (objectSlot == -1 && !base.ai.TryFindItemInInventory(FindObject, FindBetterObject, out objectSlot))
			{
				if ((Object)(object)base.TargetItem != (Object)null)
				{
					LethalBotAI.DictJustDroppedItems[base.TargetItem] = Time.realtimeSinceStartup;
					base.TargetItem = null;
				}
				ChangeBackToPreviousState();
				return;
			}
			Vector3 closestSideToDoor = GetClosestSideToDoor();
			RaycastHit val4 = default(RaycastHit);
			if (attemptToUnlockTimer > 0f || !Physics.Linecast(((Component)npcController.Npc.gameplayCamera).transform.position, closestSideToDoor, ref val4, 2816) || (Object)(object)((Component)((RaycastHit)(ref val4)).transform).GetComponent<DoorLock>() == (Object)(object)targetDoor || (Object)(object)((Component)((RaycastHit)(ref val4)).transform).GetComponent<TriggerPointToDoor>()?.pointToDoor == (Object)(object)targetDoor)
			{
				npcController.OrderToLookAtPosition(closestSideToDoor, EnumLookAtPriority.HIGH_PRIORITY, ((EnemyAI)base.ai).AIIntervalTime);
			}
			else
			{
				npcController.OrderToLookForward();
			}
			Vector3 placePosition = doorPos.Value - ((Component)npcController.Npc).transform.position;
			float sqrMagnitude = ((Vector3)(ref placePosition)).sqrMagnitude;
			if (sqrMagnitude < 1f && !Object.op_Implicit((Object)(object)npcController.Npc.inAnimationWithEnemy) && !npcController.Npc.activatingItem)
			{
				base.ai.StopMoving();
				GrabbableObject heldItem = base.ai.HeldItem;
				if ((Object)(object)heldItem != (Object)null && !FindObject(heldItem) && heldItem.itemProperties.twoHanded)
				{
					droppedHeldItem = heldItem;
					LethalBotAI lethalBotAI = base.ai;
					placePosition = default(Vector3);
					lethalBotAI.DropItem(placeObject: false, null, placePosition);
				}
				else if ((Object)(object)heldItem == (Object)null || !FindObject(heldItem))
				{
					base.ai.SwitchItemSlotsAndSync(objectSlot);
				}
				else if (attemptToUnlockTimer > 3f)
				{
					if (heldItem is KeyItem)
					{
						targetDoor.UnlockDoorSyncWithServer();
						npcController.Npc.DespawnHeldObject();
						return;
					}
					LockPicker val5 = (LockPicker)(object)((heldItem is LockPicker) ? heldItem : null);
					if (val5 != null)
					{
						MethodInfo methodInfo = AccessTools.Method(typeof(LockPicker), "GetLockPickerDoorPosition", (Type[])null, (Type[])null);
						bool flag = (bool)methodInfo.Invoke(val5, new object[1] { targetDoor });
						val5.PlaceLockPickerServerRpc(NetworkObjectReference.op_Implicit(((NetworkBehaviour)targetDoor).NetworkObject), flag);
						val5.PlaceOnDoor(targetDoor, flag);
						placedLockpicker = true;
					}
					else
					{
						targetDoor.UnlockDoorSyncWithServer();
					}
				}
				else
				{
					attemptToUnlockTimer += ((EnemyAI)base.ai).AIIntervalTime;
					heldItem.UseItemOnClient(true);
					if (heldItem is LockPicker)
					{
						placedLockpicker = true;
					}
				}
			}
			else
			{
				SelectBestItemFromInventory();
				base.ai.SetDestinationToPositionLethalBotAI(doorPos.Value);
				if (sqrMagnitude > 64f)
				{
					npcController.OrderToSprint();
				}
				else
				{
					npcController.OrderToStopSprint();
				}
				base.ai.OrderMoveToDestination();
			}
		}

		private Vector3 GetClosestSideToDoor()
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: 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_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)targetDoor == (Object)null)
			{
				return Vector3.zero;
			}
			Vector3 val = targetDoor.lockPickerPosition.position - ((Component)npcController.Npc).transform.position;
			float sqrMagnitude = ((Vector3)(ref val)).sqrMagnitude;
			val = targetDoor.lockPickerPosition2.position - ((Component)npcController.Npc).transform.position;
			float sqrMagnitude2 = ((Vector3)(ref val)).sqrMagnitude;
			if (sqrMagnitude < sqrMagnitude2)
			{
				return targetDoor.lockPickerPosition.position;
			}
			return targetDoor.lockPickerPosition2.position;
		}

		public override void TryPlayCurrentStateVoiceAudio()
		{
		}

		protected override bool FindObject(GrabbableObject item)
		{
			return LethalBotAI.IsItemKey(item);
		}

		protected override bool FindBetterObject(GrabbableObject currentBest, GrabbableObject canidate)
		{
			if (!(currentBest is KeyItem) && canidate is KeyItem)
			{
				return true;
			}
			return false;
		}

		public new static void RegisterSignalTranslatorCommands()
		{
			ChatCommandsManager.RegisterCommandForState<UseKeyOnLockedDoorState>(new ChatCommand("return", delegate(AIState state, LethalBotAI lethalBotAI, PlayerControllerB playerWhoSentMessage, string message, bool isVoice)
			{
				UseKeyOnLockedDoorState useKeyOnLockedDoorState = (UseKeyOnLockedDoorState)state;
				useKeyOnLockedDoorState.previousAIState = new ReturnToShipState(state);
				return true;
			}));
		}
	}
	public class UseTZPInhalantState : AIState
	{
		private float desiredDrunknessAmount;

		private GrabbableObject? droppedHeldItem;

		public UseTZPInhalantState(AIState oldState, float desiredDrunknessAmount)
			: base(oldState)
		{
			base.CurrentState = EnumAIStates.UseTZPInhalant;
			this.desiredDrunknessAmount = Mathf.Clamp01(desiredDrunknessAmount);
		}

		public override void OnEnterState()
		{
			if (!hasBeenStarted && desiredDrunknessAmount <= 0f)
			{
				Plugin.LogError($"A negative number or zero was given for desired amount of drunkness. Got {desiredDrunknessAmount}");
				ChangeBackToPreviousState();
			}
			else
			{
				base.OnEnterState();
			}
		}

		public override void OnExitState(AIState newState)
		{
			GrabbableObject heldItem = base.ai.HeldItem;
			if ((Object)(object)heldItem != (Object)null)
			{
				heldItem.UseItemOnClient(false);
			}
			if ((Object)(object)droppedHeldItem != (Object)null)
			{
				LethalBotAI.DictJustDroppedItems.Remove(droppedHeldItem);
			}
			base.OnExitState(newState);
		}

		public override void DoAI()
		{
			//IL_010e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			EnemyAI val = base.ai.CheckLOSForEnemy(90f, 40, 5);
			if ((Object)(object)val != (Object)null)
			{
				base.ai.State = new PanikState(this, val);
				return;
			}
			GrabbableObject heldItem = base.ai.HeldItem;
			TetraChemicalItem val2 = (TetraChemicalItem)(object)((heldItem is TetraChemicalItem) ? heldItem : null);
			if (desiredDrunknessAmount <= npcController.Npc.drunkness)
			{
				ChangeBackToPreviousState();
				return;
			}
			int objectSlot = (((Object)(object)val2 != (Object)null && !((GrabbableObject)val2).itemUsedUp) ? npcController.Npc.currentItemSlot : (-1));
			if (objectSlot == -1)
			{
				val2 = null;
				if (!base.ai.HasGrabbableObjectInInventory((Func<GrabbableObject, bool>)FindObject, out objectSlot))
				{
					ChangeBackToPreviousState();
					return;
				}
			}
			base.ai.StopMoving();
			if (Object.op_Implicit((Object)(object)npcController.Npc.inAnimationWithEnemy))
			{
				return;
			}
			if ((Object)(object)heldItem == (Object)null || (Object)(object)val2 == (Object)null)
			{
				if ((Object)(object)heldItem != (Object)null && heldItem.itemProperties.twoHanded)
				{
					droppedHeldItem = heldItem;
					base.ai.DropItem();
				}
				else if (npcController.Npc.activatingItem)
				{
					if (heldItem != null)
					{
						heldItem.UseItemOnClient(false);
					}
				}
				else
				{
					base.ai.SwitchItemSlotsAndSync(objectSlot);
				}
			}
			else if (!npcController.Npc.activatingItem && base.ai.CanUseHeldItem())
			{
				((GrabbableObject)val2).UseItemOnClient(true);
			}
		}

		public override void UseHeldItem()
		{
			if (!(base.ai.HeldItem is TetraChemicalItem))
			{
				base.UseHeldItem();
			}
		}

		public override void TryPlayCurrentStateVoiceAudio()
		{
		}

		protected override bool FindObject(GrabbableObject item)
		{
			TetraChemicalItem val = (TetraChemicalItem)(object)((item is TetraChemicalItem) ? item : null);
			if (val != null && !((GrabbableObject)val).itemUsedUp)
			{
				return true;
			}
			return false;
		}
	}
}
namespace System.Diagnostics.CodeAnalysis
{
	[AttributeUsage(AttributeTargets.Method | AttributeTargets.Property, Inherited = false, AllowMultiple = true)]
	internal sealed class MemberNotNullAttribute : Attribute
	{
		public string[] Members { get; }

		public MemberNotNullAttribute(string member)
		{
			Members = new string[1] { member };
		}

		public MemberNotNullAttribute(params string[] members)
		{
			Members = members;
		}
	}
	[AttributeUsage(AttributeTargets.Method | AttributeTargets.Property, Inherited = false, AllowMultiple = true)]
	internal sealed class MemberNotNullWhenAttribute : Attribute
	{
		public bool ReturnValue { get; }

		public string[] Members { get; }

		public MemberNotNullWhenAttribute(bool returnValue, string member)
		{
			ReturnValue = returnValue;
			Members = new string[1] { member };
		}

		public MemberNotNullWhenAttribute(bool returnValue, params string[] members)
		{
			ReturnValue = returnValue;
			Members = members;
		}
	}
}
namespace __GEN
{
	internal class NetworkVariableSerializationHelper
	{
		[RuntimeInitializeOnLoadMethod]
		internal static void InitializeSerialization()
		{
			NetworkVariableSerializationTypes.InitializeSerializer_UnmanagedINetworkSerializable<LethalBotGroupMemberNetworkSerializable>();
			NetworkVariableSerializationTypes.InitializeEqualityChecker_UnmanagedIEquatable<LethalBotGroupMemberNetworkSerializable>();
			NetworkVariableSerializationTypes.InitializeSerializer_UnmanagedByMemcpy<EnumBotSpawnState>();
			NetworkVariableSerializationTypes.InitializeEqualityChecker_UnmanagedValueEquals<EnumBotSpawnState>();
			NetworkVariableSerializationTypes.InitializeSerializer_UnmanagedByMemcpy<bool>();
			NetworkVariableSerializationTypes.InitializeEqualityChecker_UnmanagedIEquatable<bool>();
			NetworkVariableSerializationTypes.InitializeSerializer_UnmanagedINetworkSerializable<NetworkObjectReference>();
			NetworkVariableSerializationTypes.InitializeEqualityChecker_UnmanagedIEquatable<NetworkObjectReference>();
			NetworkVariableSerializationTypes.InitializeSerializer_UnmanagedINetworkSerializable<NetworkBehaviourReference>();
			NetworkVariableSerializationTypes.InitializeEqualityChecker_UnmanagedIEquatable<NetworkBehaviourReference>();
			NetworkVariableSerializationTypes.InitializeSerializer_UnmanagedByMemcpy<float>();
			NetworkVariableSerializationTypes.InitializeEqualityChecker_UnmanagedIEquatable<float>();
			NetworkVariableSerializationTypes.InitializeSerializer_ManagedINetworkSerializable<LethalBotInfection>();
			NetworkVariableSerializationTypes.InitializeEqualityChecker_ManagedIEquatable<LethalBotInfection>();
		}
	}
}
namespace LethalBots.NetcodePatcher
{
	[AttributeUsage(AttributeTargets.Module)]
	internal class NetcodePatchedAssemblyAttribute : Attribute
	{
	}
}