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.Network;
using LCAutoRevive.Patches;
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.PathfindingLib;
using LethalBots.Patches.ModPatches.Peepers;
using LethalBots.Patches.ModPatches.ReviveCompany;
using LethalBots.Patches.ModPatches.SelfSortingStorage;
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 LethalBots.Utils.Items.Weapons;
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 PathfindingLib.API;
using PathfindingLib.Utilities.Native;
using ReservedItemSlotCore;
using ReservedItemSlotCore.Data;
using ReservedItemSlotCore.Patches;
using Scoops.gameobjects;
using Scoops.misc;
using Scoops.patch;
using Scoops.service;
using SelfSortingStorage.Cupboard;
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;
using UsualScrap.Patches;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: IgnoresAccessChecksTo("Assembly-CSharp-firstpass")]
[assembly: IgnoresAccessChecksTo("Assembly-CSharp")]
[assembly: IgnoresAccessChecksTo("com.github.teamxiaolan.dawnlib.compatibility")]
[assembly: IgnoresAccessChecksTo("com.github.teamxiaolan.dawnlib")]
[assembly: IgnoresAccessChecksTo("com.github.teamxiaolan.dawnlib.dusk")]
[assembly: IgnoresAccessChecksTo("com.github.teamxiaolan.dawnlib.interfaces")]
[assembly: IgnoresAccessChecksTo("DunGen")]
[assembly: IgnoresAccessChecksTo("LethalPhones")]
[assembly: IgnoresAccessChecksTo("PathfindingLib")]
[assembly: IgnoresAccessChecksTo("SelfSortingStorage")]
[assembly: IgnoresAccessChecksTo("Tomatobird.AutoRevive")]
[assembly: IgnoresAccessChecksTo("Unity.Netcode.Runtime")]
[assembly: IgnoresAccessChecksTo("UsualScrap")]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("LethalBots")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("12.1.1.0")]
[assembly: AssemblyInformationalVersion("12.1.1+90464ea8ccb154b10aba0066b98c8e053901cedc")]
[assembly: AssemblyProduct("LethalBots")]
[assembly: AssemblyTitle("LethalBots")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("12.1.1.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]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class IsUnmanagedAttribute : Attribute
	{
	}
	[CompilerGenerated]
	[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]
	[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]
	[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", "12.1.1")]
	[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.*/)]
	[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;

		internal static bool IsModSuperEclipseLoaded;

		internal static bool IsModNavmeshInCompanyReduxLoaded;

		internal static bool IsModSelfSortingStorageLoaded;

		internal static bool IsModPathfindingLibLoaded;

		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 globalObjectIdHash = BitConverter.ToUInt32(value, 0);
			NetworkObject component = LethalBotNPCPrefab.enemyPrefab.GetComponent<NetworkObject>();
			component.GlobalObjectIdHash = globalObjectIdHash;
			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 T-Rizzle.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(NavMeshPatch));
			_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(PlayerPhysicsRegionPatch));
			_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_0263: Unknown result type (might be due to invalid IL or missing references)
			//IL_0271: Expected O, but got Unknown
			//IL_02a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ac: Expected O, but got Unknown
			//IL_02db: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e7: Expected O, but got Unknown
			//IL_03f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_03fd: Expected O, but got Unknown
			//IL_042d: Unknown result type (might be due to invalid IL or missing references)
			//IL_043b: Expected O, but got Unknown
			//IL_04a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_04b5: Expected O, but got Unknown
			//IL_04e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_04f6: Expected O, but got Unknown
			//IL_0523: Unknown result type (might be due to invalid IL or missing references)
			//IL_0531: Expected O, but got Unknown
			//IL_055e: Unknown result type (might be due to invalid IL or missing references)
			//IL_056c: Expected O, but got Unknown
			//IL_0599: Unknown result type (might be due to invalid IL or missing references)
			//IL_05a7: Expected O, but got Unknown
			//IL_05d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_05e2: Expected O, but got Unknown
			//IL_062f: Unknown result type (might be due to invalid IL or missing references)
			//IL_063d: Expected O, but got Unknown
			//IL_066a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0678: Expected O, but got Unknown
			//IL_06a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_06b3: Expected O, but got Unknown
			//IL_06e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_06ee: 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");
			IsModSuperEclipseLoaded = IsModLoaded("Millie.SuperEclipse");
			IsModNavmeshInCompanyReduxLoaded = IsModLoaded("T-Rizzle.NavMeshInCompanyRedux");
			IsModSelfSortingStorageLoaded = IsModLoaded("zigzag.SelfSortingStorage");
			IsModPathfindingLibLoaded = IsModLoaded("Zaggy1024.PathfindingLib");
			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));
				ItemsManager.RegisterWeapons.AddListener((UnityAction<ItemsManager>)UsualScrapWeaponsPatch.RegisterWeaponsForBots);
			}
			if (IsModAutoReviveLoaded)
			{
				_harmony.PatchAll(typeof(AutoRevivePlayerPatch));
				_harmony.PatchAll(typeof(LethalBotAutoReviveHelper));
			}
			if (IsModSelfSortingStorageLoaded)
			{
				SelfSortingStoragePatch.InitSingleton();
			}
			if (IsModPathfindingLibLoaded)
			{
				_harmony.PatchAll(typeof(PathfindingLibPatch));
				PathfindingLibPatch.AddCustomAreaMasks();
			}
		}

		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);
		}

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

		public const string PLUGIN_NAME = "LethalBots";

		public const string PLUGIN_VERSION = "12.1.1";
	}
}
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 FieldInfoTargetPlayer = AccessTools.Field(typeof(EnemyAI), "targetPlayer");

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

		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.Items.Weapons
{
	public class KnifeInfo : WeaponInfo
	{
		public override float GetAttackRangeForWeapon(GrabbableObject weapon)
		{
			return 1f;
		}

		public override float GetWeaponAttackInterval(GrabbableObject weapon)
		{
			return 0.43f;
		}

		public override void GetWeaponAttackInfo(GrabbableObject weapon, PlayerControllerB lethalBotController, out Ray ray, out float maxFOV, out float radius, out float maxRange, out LayerMask hitMask)
		{
			//IL_0016: 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_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_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_004f: 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)
			KnifeItem val = (KnifeItem)(object)((weapon is KnifeItem) ? weapon : null);
			if (val != 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(val.knifeMask);
			}
			else
			{
				base.GetWeaponAttackInfo(weapon, lethalBotController, out ray, out maxFOV, out radius, out maxRange, out hitMask);
			}
		}
	}
	public class ShotgunInfo : WeaponInfo
	{
		public ShotgunInfo()
		{
			enemyColliders = (RaycastHit[])(object)new RaycastHit[10];
		}

		public override bool IsRanged(GrabbableObject weapon)
		{
			return true;
		}

		public override bool NeedsToReload(GrabbableObject weapon)
		{
			ShotgunItem val = (ShotgunItem)(object)((weapon is ShotgunItem) ? weapon : null);
			if (val != null)
			{
				return val.shellsLoaded < 2;
			}
			return false;
		}

		public override bool ShouldEquip(GrabbableObject weapon, PlayerControllerB lethalBotController)
		{
			ShotgunItem val = (ShotgunItem)(object)((weapon is ShotgunItem) ? weapon : null);
			if (val != null)
			{
				if (val.safetyOn)
				{
					if (NeedsToReload(weapon))
					{
						return HasAmmo(lethalBotController, (GrabbableObject)(object)val, spareOnly: true);
					}
					return false;
				}
				return true;
			}
			return false;
		}

		public override bool HasAmmo(PlayerControllerB lethalBotController, GrabbableObject weapon, bool spareOnly = false)
		{
			ShotgunItem val = (ShotgunItem)(object)((weapon is ShotgunItem) ? weapon : null);
			if (val != null)
			{
				if (!spareOnly && val.shellsLoaded > 0)
				{
					return true;
				}
				GrabbableObject itemOnlySlot = lethalBotController.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;
					}
				}
				GrabbableObject[] itemSlots = lethalBotController.ItemSlots;
				for (int i = 0; i < itemSlots.Length; i++)
				{
					GrabbableObject val3 = itemSlots[i];
					if ((Object)(object)val3 != (Object)null)
					{
						GunAmmo val4 = (GunAmmo)(object)((val3 is GunAmmo) ? val3 : null);
						Plugin.LogDebug($"Ammo null in slot #{i}?: {(Object)(object)val4 == (Object)null}");
						if ((Object)(object)val4 != (Object)null)
						{
							Plugin.LogDebug($"Ammo in slot #{i} id: {val4.ammoType}");
						}
						if ((Object)(object)val4 != (Object)null && val4.ammoType == val.gunCompatibleAmmoID)
						{
							return true;
						}
					}
				}
				return false;
			}
			return true;
		}

		public override float GetAttackRangeForWeapon(GrabbableObject weapon)
		{
			return 4f;
		}

		public override float GetWeaponAttackInterval(GrabbableObject weapon)
		{
			return 0.1f;
		}

		public override void GetWeaponAttackInfo(GrabbableObject weapon, PlayerControllerB lethalBotController, out Ray ray, out float maxFOV, out float radius, out float maxRange, out LayerMask hitMask)
		{
			//IL_0016: 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_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_003a: 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_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_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_0064: 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)
			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);
			}
			else
			{
				base.GetWeaponAttackInfo(weapon, lethalBotController, out ray, out maxFOV, out radius, out maxRange, out hitMask);
			}
		}

		public override bool CanHitWithWeapon(PlayerControllerB lethalBotController, EnemyAI currentEnemy, Collider? enemyCollider, Ray ray, float radius, float maxRange, LayerMask hitMask)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: 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_0089: Unknown result type (might be due to invalid IL or missing references)
			if (enemyColliders == null)
			{
				enemyColliders = (RaycastHit[])(object)new RaycastHit[10];
			}
			int num = Physics.SphereCastNonAlloc(ray, radius, enemyColliders, maxRange, LayerMask.op_Implicit(hitMask), (QueryTriggerInteraction)2);
			IHittable val2 = default(IHittable);
			EnemyAICollisionDetect val3 = default(EnemyAICollisionDetect);
			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)enemyCollider))
				{
					if (!((Component)((RaycastHit)(ref val)).transform).gameObject.TryGetComponent<EnemyAICollisionDetect>(ref val3))
					{
						continue;
					}
					EnemyAI mainScript = val3.mainScript;
					if (mainScript == null || !((Object)(object)mainScript == (Object)(object)currentEnemy))
					{
						continue;
					}
				}
				return true;
			}
			return false;
		}

		public override IEnumerator AttackWithWeapon(PlayerControllerB lethalBotController, GrabbableObject weapon, EnemyAI currentEnemy, Collider? enemyCollider, bool canHitTarget, Action<bool> setSkipCooldown)
		{
			if (!canHitTarget)
			{
				yield return null;
				yield break;
			}
			ShotgunItem val = (ShotgunItem)(object)((weapon is ShotgunItem) ? weapon : null);
			if (val != null)
			{
				if (val.isReloading)
				{
					yield return null;
					setSkipCooldown(obj: true);
				}
				else if (val.safetyOn)
				{
					((GrabbableObject)val).ItemInteractLeftRightOnClient(false);
					yield return null;
					setSkipCooldown(obj: true);
				}
				else if (val.shellsLoaded <= 0)
				{
					((GrabbableObject)val).ItemInteractLeftRightOnClient(true);
					yield return null;
					setSkipCooldown(obj: true);
				}
				else
				{
					weapon.UseItemOnClient(true);
				}
			}
		}

		public override void UseHeldWeapon(PlayerControllerB lethalBotController, GrabbableObject weapon, ref bool canUseLethalPhones)
		{
			ShotgunItem val = (ShotgunItem)(object)((weapon is ShotgunItem) ? weapon : null);
			if (val != null)
			{
				if (!val.safetyOn)
				{
					canUseLethalPhones = false;
					((GrabbableObject)val).ItemInteractLeftRightOnClient(false);
				}
				else if (NeedsToReload(weapon) && HasAmmo(lethalBotController, weapon, spareOnly: true))
				{
					canUseLethalPhones = false;
					((GrabbableObject)val).ItemInteractLeftRightOnClient(true);
				}
			}
		}
	}
	public class ShovelInfo : WeaponInfo
	{
		public override float GetAttackRangeForWeapon(GrabbableObject weapon)
		{
			return 2f;
		}

		public override float GetWeaponAttackInterval(GrabbableObject weapon)
		{
			return 0.78f;
		}

		public override void GetWeaponAttackInfo(GrabbableObject weapon, PlayerControllerB lethalBotController, out Ray ray, out float maxFOV, out float radius, out float maxRange, out LayerMask hitMask)
		{
			//IL_0016: 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_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_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_004f: 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)
			Shovel val = (Shovel)(object)((weapon is Shovel) ? weapon : null);
			if (val != 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(val.shovelMask);
			}
			else
			{
				base.GetWeaponAttackInfo(weapon, lethalBotController, out ray, out maxFOV, out radius, out maxRange, out hitMask);
			}
		}
	}
	public class ZapGunInfo : WeaponInfo
	{
		public ZapGunInfo()
		{
			if (enemyColliders == null)
			{
				enemyColliders = (RaycastHit[])(object)new RaycastHit[12];
			}
		}

		public override bool IsRanged(GrabbableObject weapon)
		{
			return true;
		}

		public override bool HasAmmo(PlayerControllerB lethalBotController, GrabbableObject weapon, bool spareOnly = false)
		{
			return ItemsManager.HasRequiredCharge(weapon);
		}

		public override float GetAttackRangeForWeapon(GrabbableObject weapon)
		{
			return 5f;
		}

		public override float GetWeaponAttackInterval(GrabbableObject weapon)
		{
			return 0.1f;
		}

		public override void GetWeaponAttackInfo(GrabbableObject weapon, PlayerControllerB lethalBotController, out Ray ray, out float maxFOV, out float radius, out float maxRange, out LayerMask hitMask)
		{
			//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_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_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_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_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)
			PatcherTool val = (PatcherTool)(object)((weapon is PatcherTool) ? weapon : null);
			if (val != null)
			{
				Vector3 forward = ((Component)lethalBotController.gameplayCamera).transform.forward;
				ray = new Ray(((Component)lethalBotController.gameplayCamera).transform.position - forward * 3f, forward);
				maxFOV = 60f;
				radius = 5f;
				maxRange = 5f;
				hitMask = LayerMask.op_Implicit(val.anomalyMask);
			}
			else
			{
				base.GetWeaponAttackInfo(weapon, lethalBotController, out ray, out maxFOV, out radius, out maxRange, out hitMask);
			}
		}

		public override bool CanHitWithWeapon(PlayerControllerB lethalBotController, EnemyAI currentEnemy, Collider? enemyCollider, Ray ray, float radius, float maxRange, LayerMask hitMask)
		{
			//IL_0015: 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_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)
			if (enemyColliders == null)
			{
				enemyColliders = (RaycastHit[])(object)new RaycastHit[10];
			}
			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)enemyCollider))
				{
					EnemyAI componentInParent = ((Component)((RaycastHit)(ref val)).collider).gameObject.GetComponentInParent<EnemyAI>();
					if (componentInParent == null || !((Object)(object)componentInParent == (Object)(object)currentEnemy))
					{
						num2++;
						continue;
					}
				}
				return true;
			}
			return false;
		}

		public override IEnumerator AttackWithWeapon(PlayerControllerB lethalBotController, GrabbableObject weapon, EnemyAI currentEnemy, Collider? enemyCollider, bool canHitTarget, Action<bool> setSkipCooldown)
		{
			if (!canHitTarget)
			{
				yield return null;
				yield break;
			}
			PatcherTool val = (PatcherTool)(object)((weapon is PatcherTool) ? weapon : null);
			if (val == null)
			{
				yield break;
			}
			Transform shockingTarget = lethalBotController.shockingTarget;
			if (val.isShocking)
			{
				IShockableWithGun componentInChildren = ((Component)((Component)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))
				{
					yield return null;
					setSkipCooldown(obj: true);
				}
				else
				{
					weapon.UseItemOnClient(true);
					yield return null;
					setSkipCooldown(obj: true);
				}
			}
			else if (!val.isScanning)
			{
				weapon.UseItemOnClient(true);
			}
		}
	}
}
namespace LethalBots.Utils.Helpers
{
	public struct CachedValue<T>
	{
		private readonly UpdateLimiter nextValueUpdate;

		public T Value
		{
			[CompilerGenerated]
			readonly get
			{
				return <Value>k__BackingField;
			}
			set
			{
				<Value>k__BackingField = value;
				MarkUpdated();
			}
		}

		public CachedValue(T value = default(T), float updateInterval = 1f)
		{
			<Value>k__BackingField = default(T);
			nextValueUpdate = new UpdateLimiter(updateInterval);
			Value = value;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public bool CanUpdate()
		{
			return nextValueUpdate.CanUpdate();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void MarkUpdated()
		{
			nextValueUpdate.Invalidate();
		}

		public static implicit operator T(CachedValue<T> cachedValue)
		{
			return cachedValue.Value;
		}
	}
	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 struct CountdownTimer : INetworkSerializable, IEquatable<CountdownTimer>
	{
		public const float INVALID_TIME = -1f;

		public float startTime;

		public float endTime;

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

		public CountdownTimer(float time)
			: this()
		{
			Start(time);
		}

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

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

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public bool HasStarted()
		{
			return endTime > 0f;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public float GetElapsedTime()
		{
			if (!HasStarted())
			{
				return -1f;
			}
			return Time.realtimeSinceStartup - startTime;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public bool Elapsed()
		{
			if (HasStarted())
			{
				return endTime <= Time.realtimeSinceStartup;
			}
			return false;
		}

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

		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)
		{
			return left.Equals(right);
		}

		public static bool operator !=(CountdownTimer? left, CountdownTimer? right)
		{
			return !(left == right);
		}
	}
	public class DunGenTileTracker : MonoBehaviour
	{
		private readonly UpdateLimiter updateLimiter = new UpdateLimiter();

		public int AdjacentTileDepth = 1;

		public bool CullBehindClosedDoors = true;

		public Transform? TargetOverride;

		public bool IncludeDisabledComponents;

		[CompilerGenerated]
		private Tag <DisableCullingTag>k__BackingField;

		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>k__BackingField == (Tag)null)
				{
					<DisableCullingTag>k__BackingField = StartOfRound.Instance.occlusionCuller.DisableCullingTag;
				}
				return <DisableCullingTag>k__BackingField;
			}
			[CompilerGenerated]
			set
			{
				<DisableCullingTag>k__BackingField = 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;
		}

		protected IEnumerable<Door> GetAllDoorsInDungeon(Dungeon dungeon)
		{
			foreach (GameObject door in dungeon.Doors)
			{
				if ((Object)(object)door != (Object)null)
				{
					Door component = door.GetComponent<Door>();
					if ((Object)(object)component != (Object)null)
					{
						yield return component;
					}
				}
			}
		}

		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 struct IntervalTimer : INetworkSerializable, IEquatable<IntervalTimer>
	{
		public const float INVALID_TIME = -1f;

		public float timestamp;

		public IntervalTimer()
		{
			timestamp = -1f;
		}

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

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

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

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public bool HasStarted()
		{
			return timestamp > 0f;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public float GetElapsedTime()
		{
			if (!HasStarted())
			{
				return -1f;
			}
			return Time.realtimeSinceStartup - timestamp;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public bool IsGreaterThan(float duration)
		{
			return GetElapsedTime() > duration;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public bool IsLessThan(float duration)
		{
			return GetElapsedTime() < duration;
		}

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

		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)
		{
			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 typ