using System;
using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using GameNetcodeStuff;
using LethalLib.Modules;
using Md.CaveDwellerAI;
using Md.JesterAI;
using Md.LungProp;
using Microsoft.CodeAnalysis;
using MonoDetour;
using MonoDetour.Cil;
using MonoDetour.DetourTypes;
using MonoDetour.HookGen;
using MonoDetour.Reflection.Unspeakable;
using MonoMod.Utils;
using ProjectSCP.SCP682.NetcodePatcher;
using SCP682.Configuration;
using SCP682.Hooks;
using SCP682.SCPEnemy;
using SCP682.SCPEnemy.DoorBreak;
using Unity.Netcode;
using UnityEngine;
using UnityEngine.AI;
using UnityEngine.Video;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: MonoDetourTargets(typeof(LungProp), Members = new string[] { "DisconnectFromMachinery" })]
[assembly: MonoDetourTargets(typeof(CaveDwellerAI), Members = new string[] { "Start" })]
[assembly: MonoDetourTargets(typeof(JesterAI), Members = new string[] { "Start" })]
[assembly: IgnoresAccessChecksTo("Assembly-CSharp")]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("ProjectSCP.SCP682")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.6.0")]
[assembly: AssemblyInformationalVersion("1.0.6+3117961102d0635f7dddcae92ba3892c6dadf004")]
[assembly: AssemblyProduct("ProjectSCP.SCP682")]
[assembly: AssemblyTitle("SCP682")]
[assembly: AssemblyMetadata("RepositoryUrl", "https://github.com/Hamunii/LC-SCP-682-Enemy")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
[module: NetcodePatchedAssembly]
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

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

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

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace Md.LungProp
{
	internal static class DisconnectFromMachinery
	{
		public delegate void PrefixSignature(LungProp self);

		public delegate void PostfixSignature(LungProp self, ref IEnumerator returnValue);

		public delegate void PrefixMoveNextSignature(SpeakableEnumerator<object, LungProp> self);

		public delegate void PostfixMoveNextSignature(SpeakableEnumerator<object, LungProp> self, ref bool continueEnumeration);

		public static MonoDetourHook Prefix(PrefixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PrefixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook Postfix(PostfixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PostfixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook ILHook(Manipulator manipulator, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).ILHook(Target(), manipulator, config, applyByDefault);
		}

		public static MonoDetourHook PrefixMoveNext(PrefixMoveNextSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PrefixDetour>((MethodBase)StateMachineTarget(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook PostfixMoveNext(PostfixMoveNextSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PostfixDetour>((MethodBase)StateMachineTarget(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook ILHookMoveNext(Manipulator manipulator, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).ILHook((MethodBase)StateMachineTarget(), manipulator, config, applyByDefault);
		}

		public static MethodBase Target()
		{
			Type typeFromHandle = typeof(LungProp);
			MethodInfo method = typeFromHandle.GetMethod("DisconnectFromMachinery", (BindingFlags)(-1), null, Array.Empty<Type>(), null);
			if ((object)method == null)
			{
				throw new MissingMethodException("LungProp", "DisconnectFromMachinery");
			}
			return method;
		}

		public static MethodInfo StateMachineTarget()
		{
			return Extensions.GetStateMachineTarget((MethodInfo)Target());
		}
	}
}
namespace Md.JesterAI
{
	internal static class Start
	{
		public delegate void PrefixSignature(JesterAI self);

		public delegate void PostfixSignature(JesterAI self);

		public static MonoDetourHook Prefix(PrefixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PrefixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook Postfix(PostfixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PostfixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook ILHook(Manipulator manipulator, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).ILHook(Target(), manipulator, config, applyByDefault);
		}

		public static MethodBase Target()
		{
			Type typeFromHandle = typeof(JesterAI);
			MethodInfo method = typeFromHandle.GetMethod("Start", (BindingFlags)(-1), null, Array.Empty<Type>(), null);
			if ((object)method == null)
			{
				throw new MissingMethodException("JesterAI", "Start");
			}
			return method;
		}
	}
}
namespace Md.CaveDwellerAI
{
	internal static class Start
	{
		public delegate void PrefixSignature(CaveDwellerAI self);

		public delegate void PostfixSignature(CaveDwellerAI self);

		public static MonoDetourHook Prefix(PrefixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PrefixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook Postfix(PostfixSignature hook, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).Hook<PostfixDetour>(Target(), (Delegate)hook, config, applyByDefault);
		}

		public static MonoDetourHook ILHook(Manipulator manipulator, MonoDetourConfig? config = null, bool applyByDefault = true, MonoDetourManager? manager = null)
		{
			return (manager ?? DefaultMonoDetourManager.Instance).ILHook(Target(), manipulator, config, applyByDefault);
		}

		public static MethodBase Target()
		{
			Type typeFromHandle = typeof(CaveDwellerAI);
			MethodInfo method = typeFromHandle.GetMethod("Start", (BindingFlags)(-1), null, Array.Empty<Type>(), null);
			if ((object)method == null)
			{
				throw new MissingMethodException("CaveDwellerAI", "Start");
			}
			return method;
		}
	}
}
namespace MonoDetour.HookGen
{
	internal static class DefaultMonoDetourManager
	{
		internal static MonoDetourManager Instance { get; } = New();


		internal static MonoDetourManager New()
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			return new MonoDetourManager(typeof(DefaultMonoDetourManager).Assembly.GetName().Name);
		}
	}
	[AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Class, AllowMultiple = true, Inherited = false)]
	internal class MonoDetourTargetsAttribute : Attribute, IMonoDetourTargets
	{
		public Type? TargetType { get; }

		public bool IncludeNestedTypes { get; set; }

		public string[]? Members { get; set; }

		public string[]? MemberNamePrefixes { get; set; }

		public string[]? MemberNameSuffixes { get; set; }

		public bool GenerateControlFlowVariants { get; set; }

		public MonoDetourTargetsAttribute(Type? targetType = null)
		{
			TargetType = targetType;
			IncludeNestedTypes = true;
			base..ctor();
		}
	}
}
namespace BepInEx
{
	[AttributeUsage(AttributeTargets.Class, Inherited = false, AllowMultiple = false)]
	[Conditional("CodeGeneration")]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class BepInAutoPluginAttribute : Attribute
	{
		public BepInAutoPluginAttribute(string? id = null, string? name = null, string? version = null)
		{
		}
	}
}
namespace BepInEx.Preloader.Core.Patching
{
	[AttributeUsage(AttributeTargets.Class, Inherited = false, AllowMultiple = false)]
	[Conditional("CodeGeneration")]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class PatcherAutoPluginAttribute : Attribute
	{
		public PatcherAutoPluginAttribute(string? id = null, string? name = null, string? version = null)
		{
		}
	}
}
namespace Microsoft.CodeAnalysis
{
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace SCP682
{
	internal static class AddEnemyScript
	{
		internal static void SCP682AI(EnemyType enemyType, AssetBundle assets)
		{
			GameObject enemyPrefab = enemyType.enemyPrefab;
			SCP682AI sCP682AI = enemyPrefab.AddComponent<SCP682AI>();
			((EnemyAI)sCP682AI).enemyType = enemyType;
			((EnemyAI)sCP682AI).creatureAnimator = enemyPrefab.GetComponentInChildren<Animator>();
			((EnemyAI)sCP682AI).creatureVoice = ((Component)enemyPrefab.transform.Find("ModelRoot/CrocodileModel/CG/Pelvis/CreatureVoice")).GetComponent<AudioSource>();
			((EnemyAI)sCP682AI).creatureSFX = ((Component)enemyPrefab.transform.Find("CreatureSFX")).GetComponent<AudioSource>();
			((EnemyAI)sCP682AI).eye = enemyPrefab.transform.Find("Eye");
			((EnemyAI)sCP682AI).dieSFX = assets.LoadAsset<AudioClip>("SkibidiDeath");
			((EnemyAI)sCP682AI).enemyBehaviourStates = (EnemyBehaviourState[])(object)new EnemyBehaviourState[20];
			((EnemyAI)sCP682AI).AIIntervalTime = 0.2f;
			((EnemyAI)sCP682AI).agent = enemyPrefab.GetComponent<NavMeshAgent>();
			((EnemyAI)sCP682AI).updatePositionThreshold = 0.1f;
			((EnemyAI)sCP682AI).syncMovementSpeed = 0.22f;
			((EnemyAI)sCP682AI).enemyHP = 18;
			EnemyAICollisionDetect componentInChildren = enemyPrefab.GetComponentInChildren<EnemyAICollisionDetect>();
			componentInChildren.mainScript = (EnemyAI)(object)sCP682AI;
			DoorDestroyerCollider doorDestroyerCollider = ((Component)componentInChildren).gameObject.AddComponent<DoorDestroyerCollider>();
			doorDestroyerCollider.AI = sCP682AI;
		}

		internal static void RemoveComponent<T>(this GameObject gameObject) where T : Component
		{
			T component = gameObject.GetComponent<T>();
			Object.Destroy((Object)(object)component);
		}
	}
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInPlugin("ProjectSCP.SCP682", "SCP682", "1.0.6")]
	public class Plugin : BaseUnityPlugin
	{
		public static AssetBundle? modAssets;

		internal static EnemyType SCP682ET;

		public const string Id = "ProjectSCP.SCP682";

		internal static ManualLogSource Logger { get; private set; }

		internal static PluginConfig BoundConfig { get; private set; }

		public static string Name => "SCP682";

		public static string Version => "1.0.6";

		private void Awake()
		{
			Logger = ((BaseUnityPlugin)this).Logger;
			Stopwatch stopwatch = Stopwatch.StartNew();
			Logger.LogInfo((object)("Plugin ProjectSCP.SCP682 " + Version + " started loading..."));
			BoundConfig = new PluginConfig(((BaseUnityPlugin)this).Config);
			InitializeNetworkBehaviours();
			string path = Path.Combine(Path.GetDirectoryName(((BaseUnityPlugin)this).Info.Location), "SCP682Assets");
			modAssets = AssetBundle.LoadFromFile(Path.Combine(path, "scp682assets"));
			if (modAssets == null)
			{
				Logger.LogError((object)"Failed to load custom assets.");
				return;
			}
			SFX.InitializeSFX(modAssets);
			SCP682ET = modAssets.LoadAsset<EnemyType>("SCP682ET");
			TerminalNode val = modAssets.LoadAsset<TerminalNode>("SCP682TN");
			AssetBundle val2 = AssetBundle.LoadFromFile(Path.Combine(path, "scp682videobundle"));
			VideoClip displayVideo = val2.LoadAsset<VideoClip>("SCP682Spin");
			val.displayVideo = displayVideo;
			AddEnemyScript.SCP682AI(SCP682ET, modAssets);
			NetworkPrefabs.RegisterNetworkPrefab(SCP682ET.enemyPrefab);
			Enemies.RegisterEnemy(SCP682ET, 20, (LevelTypes)(-1), val, (TerminalKeyword)null);
			JesterListHook.Init();
			ApparatusTakenHook.Init();
			CaveDwellerList.Init();
			stopwatch.Stop();
			Logger.LogInfo((object)string.Format("{0} loaded in {1}ms!", "ProjectSCP.SCP682", stopwatch.ElapsedMilliseconds));
		}

		private static void InitializeNetworkBehaviours()
		{
			Type[] array;
			try
			{
				array = Assembly.GetExecutingAssembly().GetTypes();
			}
			catch (ReflectionTypeLoadException ex)
			{
				array = ex.Types.Where((Type t) => t != null).ToArray();
			}
			Type[] array2 = array;
			foreach (Type type in array2)
			{
				MethodInfo[] methods = type.GetMethods(BindingFlags.Instance | BindingFlags.Static | BindingFlags.NonPublic);
				MethodInfo[] array3 = methods;
				foreach (MethodInfo methodInfo in array3)
				{
					object[] customAttributes = methodInfo.GetCustomAttributes(typeof(RuntimeInitializeOnLoadMethodAttribute), inherit: false);
					if (customAttributes.Length != 0)
					{
						methodInfo.Invoke(null, null);
					}
				}
			}
		}
	}
	internal static class PLog
	{
		internal static void Log(object data)
		{
			Plugin.Logger.LogInfo(data);
		}

		internal static void LogWarning(object data)
		{
			Plugin.Logger.LogWarning(data);
		}

		internal static void LogError(object data)
		{
			Plugin.Logger.LogError(data);
		}
	}
}
namespace SCP682.Hooks
{
	internal static class ApparatusTakenHook
	{
		internal static void Init()
		{
			DisconnectFromMachinery.PostfixMoveNext(Postfix_LungProp_DisconnectFromMachinery_MoveNext);
		}

		private static void Postfix_LungProp_DisconnectFromMachinery_MoveNext(SpeakableEnumerator<object, LungProp> self, ref bool continueEnumeration)
		{
			if (!continueEnumeration)
			{
				if (Random.Range(0, 2) == 0)
				{
					SpawnSCP682(outside: true);
				}
				else
				{
					SpawnSCP682(outside: false);
				}
			}
		}

		internal static void SpawnSCP682(bool outside)
		{
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			if (NetworkManager.Singleton.IsHost && Plugin.SCP682ET.numberSpawned <= 0)
			{
				RoundManager instance = RoundManager.Instance;
				GameObject[] array;
				if (outside)
				{
					array = GameObject.FindGameObjectsWithTag("OutsideAINode");
					instance.currentOutsideEnemyPower += Plugin.SCP682ET.PowerLevel;
				}
				else
				{
					array = GameObject.FindGameObjectsWithTag("AINode");
					instance.currentEnemyPower += Plugin.SCP682ET.PowerLevel;
				}
				EnemyType sCP682ET = Plugin.SCP682ET;
				sCP682ET.numberSpawned++;
				Vector3 position = array[instance.AnomalyRandom.Next(0, array.Length)].transform.position;
				position = instance.GetRandomNavMeshPositionInBoxPredictable(position, 10f, default(NavMeshHit), instance.AnomalyRandom, instance.GetLayermaskForEnemySizeLimit(Plugin.SCP682ET, false, -1), 1f);
				position = instance.PositionWithDenialPointsChecked(position, array, Plugin.SCP682ET, -1f, (Random)null);
				NetworkObjectReference val = instance.SpawnEnemyGameObject(position, 0f, 1, Plugin.SCP682ET);
				NetworkObject val2 = default(NetworkObject);
				if (!((NetworkObjectReference)(ref val)).TryGet(ref val2, (NetworkManager)null))
				{
					Plugin.Logger.LogError((object)"Couldn't get network object for spawned enemy!");
					return;
				}
				SCP682AI component = ((Component)val2).GetComponent<SCP682AI>();
				((EnemyAI)component).enemyType.isOutsideEnemy = outside;
			}
		}
	}
	internal static class CaveDwellerList
	{
		[CompilerGenerated]
		private sealed class <GetBabyCaveDwellers>d__3 : IEnumerable<CaveDwellerAI>, IEnumerable, IEnumerator<CaveDwellerAI>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private CaveDwellerAI <>2__current;

			private int <>l__initialThreadId;

			private int <i>5__2;

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

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

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

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

			private bool MoveNext()
			{
				int num = <>1__state;
				if (num != 0)
				{
					if (num != 1)
					{
						return false;
					}
					<>1__state = -1;
					goto IL_007b;
				}
				<>1__state = -1;
				<i>5__2 = 0;
				goto IL_008b;
				IL_007b:
				<i>5__2++;
				goto IL_008b;
				IL_008b:
				if (<i>5__2 < caveDwellerEnemies.Count)
				{
					CaveDwellerAI val = caveDwellerEnemies[<i>5__2];
					if ((Object)(object)val == (Object)null || ((EnemyAI)val).currentBehaviourStateIndex != 0)
					{
						caveDwellerEnemies.RemoveAt(<i>5__2);
						<i>5__2--;
						goto IL_007b;
					}
					<>2__current = val;
					<>1__state = 1;
					return true;
				}
				return false;
			}

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

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

			[DebuggerHidden]
			IEnumerator<CaveDwellerAI> IEnumerable<CaveDwellerAI>.GetEnumerator()
			{
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					return this;
				}
				return new <GetBabyCaveDwellers>d__3(0);
			}

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

		public static List<CaveDwellerAI?> caveDwellerEnemies = new List<CaveDwellerAI>();

		internal static void Init()
		{
			Md.CaveDwellerAI.Start.Postfix(Postfix_CaveDwellerAI_Start);
		}

		private static void Postfix_CaveDwellerAI_Start(CaveDwellerAI self)
		{
			caveDwellerEnemies.Add(self);
		}

		[IteratorStateMachine(typeof(<GetBabyCaveDwellers>d__3))]
		public static IEnumerable<CaveDwellerAI> GetBabyCaveDwellers()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <GetBabyCaveDwellers>d__3(-2);
		}
	}
	internal static class JesterListHook
	{
		[CompilerGenerated]
		private sealed class <GetJesters>d__3 : IEnumerable<JesterAI>, IEnumerable, IEnumerator<JesterAI>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private JesterAI <>2__current;

			private int <>l__initialThreadId;

			private int <i>5__2;

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

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

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

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

			private bool MoveNext()
			{
				int num = <>1__state;
				if (num != 0)
				{
					if (num != 1)
					{
						return false;
					}
					<>1__state = -1;
					goto IL_0073;
				}
				<>1__state = -1;
				<i>5__2 = 0;
				goto IL_0083;
				IL_0073:
				<i>5__2++;
				goto IL_0083;
				IL_0083:
				if (<i>5__2 < jesterEnemies.Count)
				{
					JesterAI val = jesterEnemies[<i>5__2];
					if ((Object)(object)val == (Object)null)
					{
						jesterEnemies.RemoveAt(<i>5__2);
						<i>5__2--;
						goto IL_0073;
					}
					<>2__current = val;
					<>1__state = 1;
					return true;
				}
				return false;
			}

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

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

			[DebuggerHidden]
			IEnumerator<JesterAI> IEnumerable<JesterAI>.GetEnumerator()
			{
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					return this;
				}
				return new <GetJesters>d__3(0);
			}

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

		public static List<JesterAI?> jesterEnemies = new List<JesterAI>();

		internal static void Init()
		{
			Md.JesterAI.Start.Postfix(Postfix_JesterAI_Start);
		}

		private static void Postfix_JesterAI_Start(JesterAI self)
		{
			jesterEnemies.Add(self);
		}

		[IteratorStateMachine(typeof(<GetJesters>d__3))]
		public static IEnumerable<JesterAI> GetJesters()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <GetJesters>d__3(-2);
		}
	}
}
namespace SCP682.SCPEnemy
{
	public abstract class ModEnemyAI<T> : ModEnemyAINetworkLayer where T : ModEnemyAI<T>
	{
		public abstract class AIBehaviorState : AIBase
		{
			public abstract List<AIStateTransition> Transitions { get; set; }

			public abstract IEnumerator OnStateEntered();

			public virtual void Update()
			{
			}

			public virtual void LateUpdate()
			{
			}

			public virtual void AIInterval()
			{
			}

			public virtual void OnCollideWithPlayer(Collider other)
			{
			}

			public virtual void OnCollideWithEnemy(Collider other, EnemyAI? collidedEnemy)
			{
			}

			public abstract IEnumerator OnStateExit();
		}

		public abstract class AIStateTransition : AIBase
		{
			public abstract bool CanTransitionBeTaken();

			public virtual void AIInterval()
			{
			}

			public abstract AIBehaviorState NextState();

			public virtual void OnCollideWithPlayer(Collider other)
			{
			}
		}

		public abstract class AIBase
		{
			public T self;

			public NavMeshAgent Agent => ((EnemyAI)self).agent;

			public PlayerControllerB? TargetPlayer
			{
				get
				{
					return self.targetPlayer;
				}
				set
				{
					self.targetPlayer = value;
				}
			}

			public Random EnemyRandom => self.enemyRandom;

			public Animator CreatureAnimator => ((EnemyAI)self).creatureAnimator;

			public AudioSource CreatureSFX => ((EnemyAI)self).creatureSFX;

			public AudioSource CreatureVoice => ((EnemyAI)self).creatureVoice;
		}

		private class TransitionType
		{
			internal readonly Type type;

			internal readonly bool isTransition;

			public TransitionType(Type type, bool isTransition)
			{
				this.type = type;
				this.isTransition = isTransition;
				base..ctor();
			}
		}

		public enum PlayerState
		{
			Dead,
			Outside,
			Inside,
			Ship
		}

		[CompilerGenerated]
		private sealed class <AllPlayers>d__41 : IEnumerable<PlayerControllerB>, IEnumerable, IEnumerator<PlayerControllerB>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private PlayerControllerB <>2__current;

			private int <>l__initialThreadId;

			private PlayerControllerB[] <>7__wrap1;

			private int <>7__wrap2;

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

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

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

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

			private bool MoveNext()
			{
				int num = <>1__state;
				if (num != 0)
				{
					if (num != 1)
					{
						return false;
					}
					<>1__state = -1;
					goto IL_0065;
				}
				<>1__state = -1;
				<>7__wrap1 = StartOfRound.Instance.allPlayerScripts;
				<>7__wrap2 = 0;
				goto IL_0073;
				IL_0065:
				<>7__wrap2++;
				goto IL_0073;
				IL_0073:
				if (<>7__wrap2 < <>7__wrap1.Length)
				{
					PlayerControllerB val = <>7__wrap1[<>7__wrap2];
					if (!val.isPlayerDead && val.isPlayerControlled)
					{
						<>2__current = val;
						<>1__state = 1;
						return true;
					}
					goto IL_0065;
				}
				<>7__wrap1 = null;
				return false;
			}

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

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

			[DebuggerHidden]
			IEnumerator<PlayerControllerB> IEnumerable<PlayerControllerB>.GetEnumerator()
			{
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					return this;
				}
				return new <AllPlayers>d__41(0);
			}

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

		[CompilerGenerated]
		private sealed class <GetAllTransitions>d__28 : IEnumerable<AIStateTransition>, IEnumerable, IEnumerator<AIStateTransition>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private AIStateTransition <>2__current;

			private int <>l__initialThreadId;

			public ModEnemyAI<T> <>4__this;

			private List<AIStateTransition>.Enumerator <>7__wrap1;

			ModEnemyAI<T>.AIStateTransition IEnumerator<AIStateTransition>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				switch (<>1__state)
				{
				case -3:
				case 1:
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
					break;
				case -4:
				case 2:
					try
					{
					}
					finally
					{
						<>m__Finally2();
					}
					break;
				}
				<>7__wrap1 = default(List<AIStateTransition>.Enumerator);
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				try
				{
					int num = <>1__state;
					ModEnemyAI<T> modEnemyAI = <>4__this;
					switch (num)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<>7__wrap1 = modEnemyAI.globalTransitions.GetEnumerator();
						<>1__state = -3;
						goto IL_007f;
					case 1:
						<>1__state = -3;
						goto IL_007f;
					case 2:
						{
							<>1__state = -4;
							break;
						}
						IL_007f:
						if (<>7__wrap1.MoveNext())
						{
							AIStateTransition current = <>7__wrap1.Current;
							modEnemyAI.InitializeStateTransition(current, modEnemyAI.self);
							<>2__current = current;
							<>1__state = 1;
							return true;
						}
						<>m__Finally1();
						<>7__wrap1 = default(List<AIStateTransition>.Enumerator);
						<>7__wrap1 = modEnemyAI.activeState.Transitions.GetEnumerator();
						<>1__state = -4;
						break;
					}
					if (<>7__wrap1.MoveNext())
					{
						AIStateTransition current2 = <>7__wrap1.Current;
						modEnemyAI.InitializeStateTransition(current2, modEnemyAI.self);
						<>2__current = current2;
						<>1__state = 2;
						return true;
					}
					<>m__Finally2();
					<>7__wrap1 = default(List<AIStateTransition>.Enumerator);
					return false;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

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

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

			private void <>m__Finally2()
			{
				<>1__state = -1;
				((IDisposable)<>7__wrap1).Dispose();
			}

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

			[DebuggerHidden]
			IEnumerator<AIStateTransition> IEnumerable<AIStateTransition>.GetEnumerator()
			{
				<GetAllTransitions>d__28 result;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					result = this;
				}
				else
				{
					result = new <GetAllTransitions>d__28(0)
					{
						<>4__this = <>4__this
					};
				}
				return result;
			}

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

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

			private object <>2__current;

			public AIBehaviorState activeState;

			public T self;

			public ModEnemyAI<T> <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				int num = <>1__state;
				ModEnemyAI<T> modEnemyAI = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					activeState.self = self;
					<>2__current = ((MonoBehaviour)modEnemyAI).StartCoroutine(activeState.OnStateEntered());
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					modEnemyAI._transitionCoroutineInProgress = null;
					return false;
				}
			}

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

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

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

			private object <>2__current;

			public string stateOrTransitionName;

			public ModEnemyAI<T> <>4__this;

			public int randomSeed;

			private AIStateTransition <localNextTransition>5__2;

			private TransitionType <transitionOrBehavior>5__3;

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

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

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

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

			private bool MoveNext()
			{
				int num = <>1__state;
				ModEnemyAI<T> modEnemyAI = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<localNextTransition>5__2 = null;
					if (!ModEnemyAI<T>._typeNameAndInstanceTypeToTransitionType.TryGetValue((stateOrTransitionName, ((object)modEnemyAI.self).GetType()), out <transitionOrBehavior>5__3))
					{
						modEnemyAI.ValidateAndCacheTransitionType(stateOrTransitionName, ref <transitionOrBehavior>5__3);
					}
					if (<transitionOrBehavior>5__3.isTransition)
					{
						<localNextTransition>5__2 = (AIStateTransition)Activator.CreateInstance(<transitionOrBehavior>5__3.type);
						modEnemyAI.InitializeStateTransition(<localNextTransition>5__2, modEnemyAI.self);
						if (<localNextTransition>5__2.NextState().GetType() == modEnemyAI.activeState.GetType())
						{
							return false;
						}
					}
					modEnemyAI.DebugLog($"{((NetworkBehaviour)modEnemyAI).__getTypeName()} #{((EnemyAI)modEnemyAI.self).thisEnemyIndex} is Exiting:  {modEnemyAI.activeState}");
					<>2__current = ((MonoBehaviour)modEnemyAI).StartCoroutine(modEnemyAI.activeState.OnStateExit());
					<>1__state = 1;
					return true;
				case 1:
				{
					<>1__state = -1;
					Type type = modEnemyAI.activeState.GetType();
					if (<localNextTransition>5__2 != null)
					{
						modEnemyAI.DebugLog($"{((NetworkBehaviour)modEnemyAI).__getTypeName()} #{((EnemyAI)modEnemyAI.self).thisEnemyIndex} is Transitioning via:  {<localNextTransition>5__2}");
						modEnemyAI.activeState = <localNextTransition>5__2.NextState();
					}
					else
					{
						modEnemyAI.DebugLog($"{((NetworkBehaviour)modEnemyAI).__getTypeName()} #{((EnemyAI)modEnemyAI.self).thisEnemyIndex} is Transitioning via: State Override");
						modEnemyAI.activeState = (AIBehaviorState)Activator.CreateInstance(<transitionOrBehavior>5__3.type);
					}
					modEnemyAI.previousStateType = type;
					modEnemyAI.DebugLog($"{((NetworkBehaviour)modEnemyAI).__getTypeName()} #{((EnemyAI)modEnemyAI.self).thisEnemyIndex} is Entering:  {modEnemyAI.activeState}");
					((MonoBehaviour)modEnemyAI).StartCoroutine(modEnemyAI.InitializeAndEnterState(modEnemyAI.activeState, modEnemyAI.self, new Random(randomSeed)));
					StartOfRound.Instance.ClientPlayerList.TryGetValue(NetworkManager.Singleton.LocalClientId, out var value);
					modEnemyAI.DebugLog($"CREATURE: {((Object)((EnemyAI)modEnemyAI).enemyType).name} #{((EnemyAI)modEnemyAI.self).thisEnemyIndex} STATE: {modEnemyAI.activeState} ON PLAYER: #{value} ({StartOfRound.Instance.allPlayerScripts[value].playerUsername})");
					return false;
				}
				}
			}

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

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

		private static readonly Dictionary<(string, Type), TransitionType> _typeNameAndInstanceTypeToTransitionType = new Dictionary<(string, Type), TransitionType>();

		internal AIBehaviorState activeState;

		internal Type? previousStateType;

		internal Random enemyRandom;

		internal float AITimer;

		internal bool printDebugs;

		internal PlayerState myValidState = PlayerState.Inside;

		internal AIStateTransition nextTransition;

		internal List<AIStateTransition> globalTransitions = new List<AIStateTransition>();

		internal T self;

		private PlayerControllerB? _lastSyncedTargetPlayer;

		public PlayerControllerB? targetPlayer
		{
			get
			{
				if (((NetworkBehaviour)this).IsOwner && (Object)(object)((EnemyAI)this).targetPlayer != (Object)(object)_lastSyncedTargetPlayer)
				{
					if (((EnemyAI)this).targetPlayer != null)
					{
						SetTargetServerRpc((int)((EnemyAI)this).targetPlayer.actualClientId);
					}
					else
					{
						SetTargetServerRpc(-1);
					}
				}
				return ((EnemyAI)this).targetPlayer;
			}
			set
			{
				if (!((Object)(object)value == (Object)(object)_lastSyncedTargetPlayer) || !((Object)(object)_lastSyncedTargetPlayer == (Object)(object)((EnemyAI)this).targetPlayer))
				{
					if (value != null)
					{
						SetTargetServerRpc((int)value.actualClientId);
					}
					else
					{
						SetTargetServerRpc(-1);
					}
				}
			}
		}

		internal abstract T GetThis();

		internal abstract AIBehaviorState GetInitialState();

		public override string __getTypeName()
		{
			return ((object)this).GetType().Name;
		}

		public override void Start()
		{
			self = GetThis();
			activeState = GetInitialState();
			enemyRandom = new Random(StartOfRound.Instance.randomMapSeed + ((EnemyAI)this).thisEnemyIndex);
			myValidState = (((EnemyAI)this).enemyType.isOutsideEnemy ? PlayerState.Outside : PlayerState.Inside);
			((EnemyAI)this).creatureAnimator.Rebind();
			((EnemyAI)this).Start();
			if (!((EnemyAI)this).agent.isOnNavMesh && ((NetworkBehaviour)this).IsOwner)
			{
				DebugLog("CREATURE " + ((NetworkBehaviour)this).__getTypeName() + " WAS NOT PLACED ON NAVMESH, DESTROYING...");
				((EnemyAI)this).KillEnemyOnOwnerClient(false);
			}
			_transitionCoroutineInProgress = ((MonoBehaviour)this).StartCoroutine(InitializeAndEnterState(activeState, self, enemyRandom));
		}

		public override void Update()
		{
			if (((EnemyAI)this).isEnemyDead)
			{
				return;
			}
			((EnemyAI)this).Update();
			AITimer += Time.deltaTime;
			if (((NetworkBehaviour)this).IsOwner)
			{
				if (_transitionCoroutineInProgress != null)
				{
					return;
				}
				foreach (AIStateTransition allTransition in GetAllTransitions())
				{
					if (allTransition.CanTransitionBeTaken() && ((NetworkBehaviour)this).IsOwner)
					{
						nextTransition = allTransition;
						TransitionStateServerRpc(nextTransition.ToString(), enemyRandom.Next());
						return;
					}
				}
			}
			activeState.Update();
		}

		internal void LateUpdate()
		{
			if (_transitionCoroutineInProgress == null)
			{
				activeState.LateUpdate();
			}
		}

		public override void DoAIInterval()
		{
			((EnemyAI)this).DoAIInterval();
			if (_transitionCoroutineInProgress != null)
			{
				return;
			}
			foreach (AIStateTransition allTransition in GetAllTransitions())
			{
				allTransition.AIInterval();
			}
			activeState.AIInterval();
		}

		public override void OnCollideWithPlayer(Collider other)
		{
			((EnemyAI)this).OnCollideWithPlayer(other);
			activeState.OnCollideWithPlayer(other);
			foreach (AIStateTransition allTransition in GetAllTransitions())
			{
				allTransition.OnCollideWithPlayer(other);
			}
		}

		public override void OnCollideWithEnemy(Collider other, EnemyAI? collidedEnemy = null)
		{
			((EnemyAI)this).OnCollideWithEnemy(other, collidedEnemy);
			activeState.OnCollideWithEnemy(other, collidedEnemy);
		}

		[IteratorStateMachine(typeof(ModEnemyAI<>.<GetAllTransitions>d__28))]
		private IEnumerable<AIStateTransition> GetAllTransitions()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <GetAllTransitions>d__28(-2)
			{
				<>4__this = this
			};
		}

		[IteratorStateMachine(typeof(ModEnemyAI<>.<InitializeAndEnterState>d__29))]
		private IEnumerator InitializeAndEnterState(AIBehaviorState activeState, T self, Random enemyRandom)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <InitializeAndEnterState>d__29(0)
			{
				<>4__this = this,
				activeState = activeState,
				self = self
			};
		}

		private void InitializeStateTransition(AIStateTransition transition, T self)
		{
			transition.self = self;
		}

		internal void DebugLog(object data)
		{
			if (printDebugs)
			{
				PLog.Log(data);
			}
		}

		internal void OverrideState(AIBehaviorState state)
		{
			if (!((EnemyAI)this).isEnemyDead)
			{
				TransitionStateServerRpc(state.ToString(), enemyRandom.Next());
			}
		}

		[IteratorStateMachine(typeof(ModEnemyAI<>.<TransitionState>d__33))]
		internal override IEnumerator TransitionState(string stateOrTransitionName, int randomSeed)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <TransitionState>d__33(0)
			{
				<>4__this = this,
				stateOrTransitionName = stateOrTransitionName,
				randomSeed = randomSeed
			};
		}

		private void ValidateAndCacheTransitionType(string stateOrTransitionName, [NotNull] ref TransitionType? transitionOrBehavior)
		{
			Type type = Type.GetType(stateOrTransitionName) ?? throw new ArgumentException("'" + stateOrTransitionName + "' wasn't found as a type!", "stateOrTransitionName");
			if (type.IsSubclassOf(typeof(AIStateTransition)))
			{
				transitionOrBehavior = new TransitionType(type, isTransition: true);
				_typeNameAndInstanceTypeToTransitionType.Add((stateOrTransitionName, ((object)self).GetType()), transitionOrBehavior);
				return;
			}
			if (type.IsSubclassOf(typeof(AIBehaviorState)))
			{
				transitionOrBehavior = new TransitionType(type, isTransition: false);
				_typeNameAndInstanceTypeToTransitionType.Add((stateOrTransitionName, ((object)self).GetType()), transitionOrBehavior);
				return;
			}
			throw new ArgumentException("'" + stateOrTransitionName + "' is neither an AIStateTransition nor an AIBehaviorState!", "stateOrTransitionName");
		}

		protected override void SetTarget(int PlayerID)
		{
			if (PlayerID == -1)
			{
				((EnemyAI)this).targetPlayer = null;
				_lastSyncedTargetPlayer = null;
				DebugLog($"Clearing target on {this}");
			}
			else if ((Object)(object)StartOfRound.Instance.allPlayerScripts[PlayerID] == (Object)null)
			{
				DebugLog($"Index invalid! {this}");
			}
			else
			{
				((EnemyAI)this).targetPlayer = StartOfRound.Instance.allPlayerScripts[PlayerID];
				_lastSyncedTargetPlayer = ((EnemyAI)this).targetPlayer;
				DebugLog($"{this} setting target to: {((EnemyAI)this).targetPlayer.playerUsername}");
			}
		}

		internal AIBehaviorState? CreatePreviousState()
		{
			if ((object)previousStateType == null)
			{
				return null;
			}
			return (AIBehaviorState)Activator.CreateInstance(previousStateType);
		}

		internal bool AnimationIsFinished(string AnimName, int layerIndex)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			AnimatorStateInfo currentAnimatorStateInfo = ((EnemyAI)this).creatureAnimator.GetCurrentAnimatorStateInfo(layerIndex);
			if (!((AnimatorStateInfo)(ref currentAnimatorStateInfo)).IsName(AnimName))
			{
				DebugLog(((NetworkBehaviour)this).__getTypeName() + ": Checking for animation " + AnimName + ", but current animation is " + ((Object)((AnimatorClipInfo)(ref ((EnemyAI)this).creatureAnimator.GetCurrentAnimatorClipInfo(layerIndex)[0])).clip).name);
				return true;
			}
			currentAnimatorStateInfo = ((EnemyAI)this).creatureAnimator.GetCurrentAnimatorStateInfo(layerIndex);
			return ((AnimatorStateInfo)(ref currentAnimatorStateInfo)).normalizedTime >= 1f;
		}

		internal bool PlayerCanBeTargeted(PlayerControllerB myPlayer)
		{
			return GetPlayerState(myPlayer) == myValidState;
		}

		internal PlayerState GetPlayerState(PlayerControllerB myPlayer)
		{
			if (myPlayer.isPlayerDead)
			{
				return PlayerState.Dead;
			}
			if (myPlayer.isInsideFactory)
			{
				return PlayerState.Inside;
			}
			if (myPlayer.isInHangarShipRoom)
			{
				return PlayerState.Ship;
			}
			return PlayerState.Outside;
		}

		internal void MoveTimerValue(ref float Timer, bool ShouldRaise = false)
		{
			if (ShouldRaise)
			{
				Timer += Time.deltaTime;
			}
			else if (!(Timer <= 0f))
			{
				Timer -= Time.deltaTime;
			}
		}

		[IteratorStateMachine(typeof(ModEnemyAI<>.<AllPlayers>d__41))]
		public IEnumerable<PlayerControllerB> AllPlayers()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <AllPlayers>d__41(-2);
		}

		public PlayerControllerB? IsAnyPlayerWithinLOS(int range = 45, float width = 60f, int proximityAwareness = -1, bool DoLinecast = true, bool PrintResults = false, bool SortByDistance = false)
		{
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			float num = range;
			PlayerControllerB result = null;
			PlayerControllerB[] allPlayerScripts = StartOfRound.Instance.allPlayerScripts;
			foreach (PlayerControllerB val in allPlayerScripts)
			{
				if (!val.isPlayerDead && val.isPlayerControlled && IsTargetPlayerWithinLOS(val, range, width, proximityAwareness, DoLinecast, PrintResults))
				{
					if (!SortByDistance)
					{
						return val;
					}
					float num2 = Vector3.Distance(((Component)val).transform.position, ((Component)this).transform.position);
					if (num2 < num)
					{
						num = num2;
						result = val;
					}
				}
			}
			return result;
		}

		public bool IsTargetPlayerWithinLOS(PlayerControllerB player, int range = 45, float width = 60f, int proximityAwareness = -1, bool DoLinecast = true, bool PrintResults = false)
		{
			//IL_0006: 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_0032: 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_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: 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)
			float num = Vector3.Distance(((Component)this).transform.position, ((Component)player.gameplayCamera).transform.position);
			bool flag = num < (float)range;
			float num2 = Vector3.Angle(((Component)((EnemyAI)this).eye).transform.forward, ((Component)player.gameplayCamera).transform.position - ((Component)((EnemyAI)this).eye).transform.position);
			bool flag2 = num2 < width;
			bool flag3 = num < (float)proximityAwareness;
			bool flag4 = DoLinecast && Physics.Linecast(((Component)((EnemyAI)this).eye).transform.position, ((Component)player).transform.position, StartOfRound.Instance.collidersRoomDefaultAndFoliage, (QueryTriggerInteraction)1);
			if (PrintResults)
			{
				DebugLog($"Target in Distance: {flag} ({num})" + $"Target within view cone: {flag2} ({num2})" + $"LOSBlocked: {flag4}");
			}
			if (!(flag && flag2))
			{
				if (flag3)
				{
					return !flag4;
				}
				return false;
			}
			return true;
		}

		public bool IsTargetPlayerWithinLOS(int range = 45, float width = 60f, int proximityAwareness = -1, bool DoLinecast = true, bool PrintResults = false)
		{
			if ((Object)(object)targetPlayer == (Object)null)
			{
				DebugLog(((NetworkBehaviour)this).__getTypeName() + " called Target Player LOS check called with null target player; returning false!");
				return false;
			}
			return IsTargetPlayerWithinLOS(targetPlayer, range, width, proximityAwareness, DoLinecast, PrintResults);
		}

		public PlayerControllerB FindNearestPlayer(bool ValidateNav = false)
		{
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			PlayerControllerB val = null;
			float num = 20000f;
			for (int i = 0; i < StartOfRound.Instance.allPlayerScripts.Length; i++)
			{
				PlayerControllerB val2 = StartOfRound.Instance.allPlayerScripts[i];
				if (!ValidateNav || ((EnemyAI)this).agent.CalculatePath(((Component)val2).transform.position, ((EnemyAI)this).path1))
				{
					float num2 = Vector3.Distance(((Component)this).transform.position, ((Component)val2).transform.position);
					if (num2 < num)
					{
						val = val2;
						num = num2;
					}
				}
			}
			if ((Object)(object)val == (Object)null)
			{
				DebugLog("There is somehow no closest player. get fucked");
				return null;
			}
			return val;
		}

		internal bool IsPlayerReachable()
		{
			if ((Object)(object)targetPlayer == (Object)null)
			{
				PLog.LogError("Player Reach Test has no target player or passed in argument!");
				return false;
			}
			return IsPlayerReachable(targetPlayer);
		}

		internal bool IsPlayerReachable(PlayerControllerB? playerToCheck)
		{
			//IL_0010: 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_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Invalid comparison between Unknown and I4
			if (playerToCheck == null)
			{
				return false;
			}
			Vector3 navMeshPosition = RoundManager.Instance.GetNavMeshPosition(((Component)playerToCheck).transform.position, RoundManager.Instance.navHit, 2.7f, -1);
			if (!RoundManager.Instance.GotNavMeshPositionResult)
			{
				DebugLog("Player Reach Test: No NavMesh position");
				return false;
			}
			((EnemyAI)this).agent.CalculatePath(navMeshPosition, ((EnemyAI)this).agent.path);
			bool flag = (int)((EnemyAI)this).agent.path.status == 0;
			DebugLog($"Player Reach Test: {flag}");
			return flag;
		}

		internal float PlayerDistanceFromShip(PlayerControllerB playerToCheck)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			if (playerToCheck == null)
			{
				PLog.LogError("PlayerNearShip check has no target player or passed in argument!");
				return -1f;
			}
			float num = Vector3.Distance(((Component)playerToCheck).transform.position, ((Component)StartOfRound.Instance.shipBounds).transform.position);
			DebugLog($"PlayerNearShip check: {num}");
			return num;
		}

		internal bool PlayerWithinRange(PlayerControllerB player, float range, bool includeYAxis = true)
		{
			return DistanceFromPlayer(player, includeYAxis) <= range;
		}

		private float DistanceFromTargetPlayer(bool IncludeYAxis)
		{
			if ((Object)(object)targetPlayer == (Object)null)
			{
				PLog.LogError($"{this} attempted DistanceFromTargetPlayer with null target; returning -1!");
				return -1f;
			}
			return DistanceFromPlayer(targetPlayer, IncludeYAxis);
		}

		private float DistanceFromPlayer(PlayerControllerB player, bool IncludeYAxis)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: 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_0014: Unknown result type (might be due to invalid IL or missing references)
			if (IncludeYAxis)
			{
				return Vector3.Distance(((Component)player).transform.position, ((Component)this).transform.position);
			}
			Vector2 val = default(Vector2);
			((Vector2)(ref val))..ctor(((Component)player).transform.position.x, ((Component)player).transform.position.z);
			Vector2 val2 = default(Vector2);
			((Vector2)(ref val2))..ctor(((Component)this).transform.position.x, ((Component)this).transform.position.z);
			return Vector2.Distance(val, val2);
		}

		public void SetEnemyOutside(bool toOutside)
		{
			if (toOutside)
			{
				myValidState = PlayerState.Outside;
				((EnemyAI)this).SetEnemyOutside(true);
			}
			else
			{
				myValidState = PlayerState.Inside;
				((EnemyAI)this).SetEnemyOutside(false);
			}
		}

		protected override void TeleportSelfToOtherEntrance(bool isOutside)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			EntranceTeleport val = RoundManager.FindMainEntranceScript(!isOutside);
			Vector3 navMeshPosition = RoundManager.Instance.GetNavMeshPosition(val.entrancePoint.position, default(NavMeshHit), 5f, -1);
			if (((NetworkBehaviour)this).IsOwner)
			{
				((Behaviour)((EnemyAI)this).agent).enabled = false;
				((Component)this).transform.position = navMeshPosition;
				((Behaviour)((EnemyAI)this).agent).enabled = true;
			}
			else
			{
				((Component)this).transform.position = navMeshPosition;
			}
			((EnemyAI)this).serverPosition = navMeshPosition;
			SetEnemyOutside(!isOutside);
			PlayEntranceOpeningSound(val);
		}

		private void PlayEntranceOpeningSound(EntranceTeleport entrance)
		{
			if (entrance.doorAudios != null && entrance.doorAudios.Length != 0)
			{
				entrance.entrancePointAudio.PlayOneShot(entrance.doorAudios[0]);
				WalkieTalkie.TransmitOneShotAudio(entrance.entrancePointAudio, entrance.doorAudios[0], 1f);
			}
		}

		internal void EnterSpecialAnimationWithPlayer(PlayerControllerB player, bool stopMovementCalculations = true)
		{
			if (player.inSpecialInteractAnimation && (Object)(object)player.currentTriggerInAnimationWith != (Object)null)
			{
				player.currentTriggerInAnimationWith.CancelAnimationExternally();
			}
			player.inSpecialInteractAnimation = true;
			player.inAnimationWithEnemy = (EnemyAI)(object)self;
			((EnemyAI)self).inSpecialAnimationWithPlayer = player;
			if (stopMovementCalculations)
			{
				((EnemyAI)self).inSpecialAnimation = true;
			}
		}

		internal bool TryGetValidPlayerFromCollision(Collider other, [NotNullWhen(true)] out PlayerControllerB? player, bool allowNonLocalPlayer = false)
		{
			player = null;
			if (((EnemyAI)this).isEnemyDead)
			{
				return false;
			}
			if (!((EnemyAI)this).ventAnimationFinished)
			{
				return false;
			}
			if (((EnemyAI)this).stunNormalizedTimer >= 0f)
			{
				return false;
			}
			player = ((Component)other).gameObject.GetComponent<PlayerControllerB>();
			if ((Object)(object)player == (Object)null || (!allowNonLocalPlayer && (Object)(object)player != (Object)(object)GameNetworkManager.Instance.localPlayerController))
			{
				return false;
			}
			if (!((EnemyAI)this).PlayerIsTargetable(player, false, false, true))
			{
				return false;
			}
			return true;
		}

		internal bool IsPlayerInsideCollider(PlayerControllerB? player, Collider collider, float colliderScale = 1f)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: 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_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)player == (Object)null)
			{
				return false;
			}
			int num = 8;
			Bounds bounds = collider.bounds;
			Vector3 center = ((Bounds)(ref bounds)).center;
			bounds = collider.bounds;
			Collider[] array = Physics.OverlapBox(center, ((Bounds)(ref bounds)).extents / 2f * colliderScale, Quaternion.identity, num);
			Collider[] array2 = array;
			foreach (Collider val in array2)
			{
				if (((Component)val).CompareTag("Player") && TryGetValidPlayerFromCollision(val, out PlayerControllerB player2, allowNonLocalPlayer: true) && (Object)(object)player2 == (Object)(object)player)
				{
					return true;
				}
			}
			return false;
		}

		protected override void __initializeVariables()
		{
			base.__initializeVariables();
		}

		protected override void __initializeRpcs()
		{
			base.__initializeRpcs();
		}

		protected internal override string __getTypeName()
		{
			return "ModEnemyAI`1";
		}
	}
	public abstract class ModEnemyAINetworkLayer : EnemyAI
	{
		internal Coroutine? _transitionCoroutineInProgress;

		[ServerRpc]
		internal void TransitionStateServerRpc(string stateName, int randomSeed)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_011d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0127: Invalid comparison between Unknown and I4
			//IL_0152: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Invalid comparison between Unknown and I4
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_010d: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				if (((NetworkBehaviour)this).OwnerClientId != networkManager.LocalClientId)
				{
					if ((int)networkManager.LogLevel <= 1)
					{
						Debug.LogError((object)"Only the owner can invoke a ServerRpc that requires ownership!");
					}
					return;
				}
				ServerRpcParams val = default(ServerRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(1357830014u, val, (RpcDelivery)0);
				bool flag = stateName != null;
				((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				if (flag)
				{
					((FastBufferWriter)(ref val2)).WriteValueSafe(stateName, false);
				}
				BytePacker.WriteValueBitPacked(val2, randomSeed);
				((NetworkBehaviour)this).__endSendServerRpc(ref val2, 1357830014u, val, (RpcDelivery)0);
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
				TransitionStateClientRpc(stateName, randomSeed);
			}
		}

		[ClientRpc]
		internal void TransitionStateClientRpc(string stateName, int randomSeed)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val = default(ClientRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(755577249u, val, (RpcDelivery)0);
				bool flag = stateName != null;
				((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				if (flag)
				{
					((FastBufferWriter)(ref val2)).WriteValueSafe(stateName, false);
				}
				BytePacker.WriteValueBitPacked(val2, randomSeed);
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 755577249u, val, (RpcDelivery)0);
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
				_transitionCoroutineInProgress = ((MonoBehaviour)this).StartCoroutine(TransitionState(stateName, randomSeed));
			}
		}

		internal abstract IEnumerator TransitionState(string stateOrTransitionName, int randomSeed);

		[ServerRpc]
		protected void SetTargetServerRpc(int PlayerID)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Invalid comparison between Unknown and I4
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Invalid comparison between Unknown and I4
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				if (((NetworkBehaviour)this).OwnerClientId != networkManager.LocalClientId)
				{
					if ((int)networkManager.LogLevel <= 1)
					{
						Debug.LogError((object)"Only the owner can invoke a ServerRpc that requires ownership!");
					}
					return;
				}
				ServerRpcParams val = default(ServerRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(314908443u, val, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val2, PlayerID);
				((NetworkBehaviour)this).__endSendServerRpc(ref val2, 314908443u, val, (RpcDelivery)0);
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
				SetTargetClientRpc(PlayerID);
			}
		}

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

		protected abstract void SetTarget(int PlayerID);

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

		[ServerRpc(RequireOwnership = false)]
		internal void SetAnimBoolOnServerRpc(string name, bool state)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_011a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				ServerRpcParams val = default(ServerRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(4090843431u, val, (RpcDelivery)0);
				bool flag = name != null;
				((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				if (flag)
				{
					((FastBufferWriter)(ref val2)).WriteValueSafe(name, false);
				}
				((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref state, default(ForPrimitives));
				((NetworkBehaviour)this).__endSendServerRpc(ref val2, 4090843431u, val, (RpcDelivery)0);
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
				if (((NetworkBehaviour)this).IsServer)
				{
					base.creatureAnimator.SetBool(name, state);
				}
			}
		}

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

		protected abstract void TeleportSelfToOtherEntrance(bool isOutside);

		protected override void __initializeVariables()
		{
			((EnemyAI)this).__initializeVariables();
		}

		protected override void __initializeRpcs()
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Expected O, but got Unknown
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Expected O, but got Unknown
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Expected O, but got Unknown
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Expected O, but got Unknown
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Expected O, but got Unknown
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Expected O, but got Unknown
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Expected O, but got Unknown
			((NetworkBehaviour)this).__registerRpc(1357830014u, new RpcReceiveHandler(__rpc_handler_1357830014), "TransitionStateServerRpc");
			((NetworkBehaviour)this).__registerRpc(755577249u, new RpcReceiveHandler(__rpc_handler_755577249), "TransitionStateClientRpc");
			((NetworkBehaviour)this).__registerRpc(314908443u, new RpcReceiveHandler(__rpc_handler_314908443), "SetTargetServerRpc");
			((NetworkBehaviour)this).__registerRpc(2468484041u, new RpcReceiveHandler(__rpc_handler_2468484041), "SetTargetClientRpc");
			((NetworkBehaviour)this).__registerRpc(217962959u, new RpcReceiveHandler(__rpc_handler_217962959), "SetAnimTriggerOnServerRpc");
			((NetworkBehaviour)this).__registerRpc(4090843431u, new RpcReceiveHandler(__rpc_handler_4090843431), "SetAnimBoolOnServerRpc");
			((NetworkBehaviour)this).__registerRpc(463666875u, new RpcReceiveHandler(__rpc_handler_463666875), "TeleportSelfToOtherEntranceClientRpc");
			((EnemyAI)this).__initializeRpcs();
		}

		private static void __rpc_handler_1357830014(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Invalid comparison between Unknown and I4
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if (rpcParams.Server.Receive.SenderClientId != target.OwnerClientId)
			{
				if ((int)networkManager.LogLevel <= 1)
				{
					Debug.LogError((object)"Only the owner can invoke a ServerRpc that requires ownership!");
				}
				return;
			}
			bool flag = default(bool);
			((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
			string stateName = null;
			if (flag)
			{
				((FastBufferReader)(ref reader)).ReadValueSafe(ref stateName, false);
			}
			int randomSeed = default(int);
			ByteUnpacker.ReadValueBitPacked(reader, ref randomSeed);
			target.__rpc_exec_stage = (__RpcExecStage)1;
			((ModEnemyAINetworkLayer)(object)target).TransitionStateServerRpc(stateName, randomSeed);
			target.__rpc_exec_stage = (__RpcExecStage)0;
		}

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

		private static void __rpc_handler_314908443(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Invalid comparison between Unknown and I4
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if (rpcParams.Server.Receive.SenderClientId != target.OwnerClientId)
			{
				if ((int)networkManager.LogLevel <= 1)
				{
					Debug.LogError((object)"Only the owner can invoke a ServerRpc that requires ownership!");
				}
			}
			else
			{
				int targetServerRpc = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref targetServerRpc);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((ModEnemyAINetworkLayer)(object)target).SetTargetServerRpc(targetServerRpc);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2468484041(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int targetClientRpc = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref targetClientRpc);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((ModEnemyAINetworkLayer)(object)target).SetTargetClientRpc(targetClientRpc);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_217962959(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				bool flag = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
				string animTriggerOnServerRpc = null;
				if (flag)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe(ref animTriggerOnServerRpc, false);
				}
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((ModEnemyAINetworkLayer)(object)target).SetAnimTriggerOnServerRpc(animTriggerOnServerRpc);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_4090843431(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				bool flag = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
				string name = null;
				if (flag)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe(ref name, false);
				}
				bool state = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref state, default(ForPrimitives));
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((ModEnemyAINetworkLayer)(object)target).SetAnimBoolOnServerRpc(name, state);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

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

		protected internal override string __getTypeName()
		{
			return "ModEnemyAINetworkLayer";
		}
	}
	internal class SCP682AI : ModEnemyAI<SCP682AI>, IVisibleThreat
	{
		public enum Speed
		{
			Stopped = 0,
			Walking = 3,
			Running = 10
		}

		public enum EnemyScale
		{
			Small,
			Big
		}

		private static class Anim
		{
			internal const string isMoving = "isMoving";

			internal const string isMovingInverted = "isMovingInverted";

			internal const string isRunning = "isRunning";

			internal const string isOnShip = "isOnShip";

			internal const string doKillEnemy = "KillEnemy";

			internal const string doRevive = "doRevive";

			internal const string doBite = "doBite";

			internal const string doRoar = "doRoar";
		}

		private class WanderToShipState : AIBehaviorState
		{
			[CompilerGenerated]
			private sealed class <OnStateEntered>d__4 : IEnumerator<object>, IEnumerator, IDisposable
			{
				private int <>1__state;

				private object <>2__current;

				public WanderToShipState <>4__this;

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

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

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

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

				private bool MoveNext()
				{
					int num = <>1__state;
					WanderToShipState wanderToShipState = <>4__this;
					if (num != 0)
					{
						return false;
					}
					<>1__state = -1;
					wanderToShipState.self.AnimatorSetBool("isMoving", value: true);
					return false;
				}

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

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

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

				private object <>2__current;

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

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

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

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

				private bool MoveNext()
				{
					if (<>1__state != 0)
					{
						return false;
					}
					<>1__state = -1;
					return false;
				}

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

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

			public override List<AIStateTransition> Transitions { get; set; } = new List<ModEnemyAI<SCP682AI>.AIStateTransition>(3)
			{
				new OnShipAmbushState.ArrivedAtShipTransition(),
				new InvestigatePlayerTransition(),
				new AttackEnemyState.TargetEnemyTransition()
			};


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

			public override void AIInterval()
			{
				//IL_000c: Unknown result type (might be due to invalid IL or missing references)
				((EnemyAI)self).SetDestinationToPosition(self.PosOnTopOfShip, false);
			}

			[IteratorStateMachine(typeof(<OnStateExit>d__6))]
			public override IEnumerator OnStateExit()
			{
				//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
				return new <OnStateExit>d__6(0);
			}
		}

		private class OnShipAmbushState : AIBehaviorState
		{
			internal class ArrivedAtShipTransition : AIStateTransition
			{
				public override bool CanTransitionBeTaken()
				{
					//IL_0006: Unknown result type (might be due to invalid IL or missing references)
					//IL_001b: Unknown result type (might be due to invalid IL or missing references)
					if (Vector3.Distance(self.PosOnTopOfShip, ((Component)self).gameObject.transform.position) < 3f)
					{
						return true;
					}
					return false;
				}

				public override AIBehaviorState NextState()
				{
					return new OnShipAmbushState();
				}
			}

			private class AmbushPlayerFromShipTransition : AIStateTransition
			{
				public override bool CanTransitionBeTaken()
				{
					if ((Object)(object)self.PlayerHeardFromNoise != (Object)null)
					{
						base.TargetPlayer = self.PlayerHeardFromNoise;
						if (!self.PlayerWithinRange(base.TargetPlayer, 30f))
						{
							return false;
						}
						return true;
					}
					base.TargetPlayer = self.FindNearestPlayer();
					return false;
				}

				public override AIBehaviorState NextState()
				{
					return new FromAmbushJumpPlayerState();
				}
			}

			private class BoredOfAmbushTransition : AIStateTransition
			{
				private float boredOfAmbushTimer = 35f;

				public override bool CanTransitionBeTaken()
				{
					boredOfAmbushTimer -= Time.deltaTime;
					if (boredOfAmbushTimer <= 0f)
					{
						return true;
					}
					return false;
				}

				public override AIBehaviorState NextState()
				{
					return new WanderThroughEntranceState();
				}
			}

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

				private object <>2__current;

				public OnShipAmbushState <>4__this;

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

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

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

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

				private bool MoveNext()
				{
					//IL_004d: Unknown result type (might be due to invalid IL or missing references)
					//IL_0069: Unknown result type (might be due to invalid IL or missing references)
					//IL_006e: Unknown result type (might be due to invalid IL or missing references)
					//IL_0095: Unknown result type (might be due to invalid IL or missing references)
					int num = <>1__state;
					OnShipAmbushState onShipAmbushState = <>4__this;
					if (num != 0)
					{
						return false;
					}
					<>1__state = -1;
					onShipAmbushState.self.AnimatorSetBool("isMoving", value: false);
					onShipAmbushState.self.AnimatorSetBool("isOnShip", value: true);
					onShipAmbushState.Agent.SetDestination(((Component)onShipAmbushState.Agent).transform.position);
					((EnemyAI)onShipAmbushState.self).destination = ((Component)onShipAmbushState.Agent).transform.position;
					((Behaviour)onShipAmbushState.Agent).enabled = false;
					((Component)onShipAmbushState.self).gameObject.transform.position = onShipAmbushState.self.PosOnTopOfShip;
					if (onShipAmbushState.self.changeScaleCoroutine != null)
					{
						((MonoBehaviour)onShipAmbushState.self).StopCoroutine(onShipAmbushState.self.changeScaleCoroutine);
					}
					((MonoBehaviour)onShipAmbushState.self).StartCoroutine(onShipAmbushState.self.ChangeEnemyScaleTo(EnemyScale.Small));
					return false;
				}

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

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

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

				private object <>2__current;

				public OnShipAmbushState <>4__this;

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

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

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

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

				private bool MoveNext()
				{
					int num = <>1__state;
					OnShipAmbushState onShipAmbushState = <>4__this;
					if (num != 0)
					{
						return false;
					}
					<>1__state = -1;
					onShipAmbushState.self.AnimatorSetBool("isMoving", value: true);
					onShipAmbushState.self.AnimatorSetBool("isOnShip", value: false);
					((Behaviour)onShipAmbushState.Agent).enabled = true;
					if (onShipAmbushState.self.changeScaleCoroutine != null)
					{
						((MonoBehaviour)onShipAmbushState.self).StopCoroutine(onShipAmbushState.self.changeScaleCoroutine);
					}
					((MonoBehaviour)onShipAmbushState.self).StartCoroutine(onShipAmbushState.self.ChangeEnemyScaleTo(EnemyScale.Big));
					return false;
				}

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

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

			public override List<AIStateTransition> Transitions { get; set; } = new List<ModEnemyAI<SCP682AI>.AIStateTransition>(2)
			{
				new AmbushPlayerFromShipTransition(),
				new BoredOfAmbushTransition()
			};


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

			public override void Update()
			{
				//IL_0040: Unknown result type (might be due to invalid IL or missing references)
				//IL_0055: Unknown result type (might be due to invalid IL or missing references)
				//IL_0064: Unknown result type (might be due to invalid IL or missing references)
				//IL_0069: Unknown result type (might be due to invalid IL or missing references)
				//IL_0079: Unknown result type (might be due to invalid IL or missing references)
				if (!((Object)(object)base.TargetPlayer == (Object)null))
				{
					self.turnCompass.LookAt(((Component)base.TargetPlayer).transform);
					((Component)self).transform.rotation = Quaternion.Lerp(((Component)self).transform.rotation, Quaternion.Euler(new Vector3(0f, self.turnCompass.eulerAngles.y, 0f)), 1f * Time.deltaTime);
				}
			}

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

		private class FromAmbushJumpPlayerState : AIBehaviorState
		{
			private class TouchTargetPlayerAndStartDraggingTransition : AIStateTransition
			{
				public override bool CanTransitionBeTaken()
				{
					return self.IsPlayerInsideCollider(base.TargetPlayer, (Collider)(object)self.mainCollider);
				}

				public override AIBehaviorState NextState()
				{
					return new DragPlayerState();
				}
			}

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

				private object <>2__current;

				public FromAmbushJumpPlayerState <>4__this;

				private Vector3 <positionBehindPlayer>5__2;

				private Vector3 <positionInBetweenInAir>5__3;

				private Vector3 <originalPosition>5__4;

				private float <normalizedTimer>5__5;

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

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

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

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

				private bool MoveNext()
				{
					//IL_0098: Unknown result type (might be due to invalid IL or missing references)
					//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
					//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
					//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
					//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
					//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
					//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
					//IL_0107: Unknown result type (might be due to invalid IL or missing references)
					//IL_010c: Unknown result type (might be due to invalid IL or missing references)
					//IL_0113: Unknown result type (might be due to invalid IL or missing references)
					//IL_0119: Unknown result type (might be due to invalid IL or missing references)
					//IL_011e: Unknown result type (might be due to invalid IL or missing references)
					//IL_0128: Unknown result type (might be due to invalid IL or missing references)
					//IL_012d: Unknown result type (might be due to invalid IL or missing references)
					//IL_0137: Unknown result type (might be due to invalid IL or missing references)
					//IL_013c: Unknown result type (might be due to invalid IL or missing references)
					//IL_0141: Unknown result type (might be due to invalid IL or missing references)
					//IL_0152: Unknown result type (might be due to invalid IL or missing references)
					//IL_0157: Unknown result type (might be due to invalid IL or missing references)
					//IL_01b6: Unknown result type (might be due to invalid IL or missing references)
					//IL_01bc: Unknown result type (might be due to invalid IL or missing references)
					//IL_01c7: Unknown result type (might be due to invalid IL or missing references)
					//IL_01cc: Unknown result type (might be due to invalid IL or missing references)
					//IL_01cf: Unknown result type (might be due to invalid IL or missing references)
					//IL_01d5: Unknown result type (might be due to invalid IL or missing references)
					//IL_01e0: Unknown result type (might be due to invalid IL or missing references)
					//IL_01e5: Unknown result type (might be due to invalid IL or missing references)
					//IL_01f2: Unknown result type (might be due to invalid IL or missing references)
					//IL_01f4: Unknown result type (might be due to invalid IL or missing references)
					//IL_01fc: Unknown result type (might be due to invalid IL or missing references)
					//IL_0239: Unknown result type (might be due to invalid IL or missing references)
					//IL_0256: Unknown result type (might be due to invalid IL or missing references)
					int num = <>1__state;
					FromAmbushJumpPlayerState fromAmbushJumpPlayerState = <>4__this;
					switch (num)
					{
					default:
						return false;
					case 0:
					{
						<>1__state = -1;
						if ((Object)(object)fromAmbushJumpPlayerState.TargetPlayer == (Object)null)
						{
							Plugin.Logger.LogError((object)"Trying to ambush player, but targetPlayer is null! Not jumping.");
							((MonoBehaviour)fromAmbushJumpPlayerState.self).StartCoroutine(fromAmbushJumpPlayerState.self.RoarAndRunCoroutine());
							return false;
						}
						if (fromAmbushJumpPlayerState.TargetPlayer.isInHangarShipRoom)
						{
							fromAmbushJumpPlayerState.self.DebugLog("TargetPlayer is inside ship, attacking without a jump.");
							((MonoBehaviour)fromAmbushJumpPlayerState.self).StartCoroutine(fromAmbushJumpPlayerState.self.RoarAndRunCoroutine());
							return false;
						}
						Vector3 val = ((Component)fromAmbushJumpPlayerState.TargetPlayer).transform.position - Vector3.Scale(new Vector3(10f, 0f, 10f), ((Component)fromAmbushJumpPlayerState.TargetPlayer).transform.forward);
						NavMeshHit val2 = default(NavMeshHit);
						if (!NavMesh.SamplePosition(val, ref val2, 10f, -1))
						{
							Plugin.Logger.LogWarning((object)"Trying to ambush player, but didn't find NavMesh near target player! Not jumping.");
							((MonoBehaviour)fromAmbushJumpPlayerState.self).StartCoroutine(fromAmbushJumpPlayerState.self.RoarAndRunCoroutine());
							return false;
						}
						<positionBehindPlayer>5__2 = ((NavMeshHit)(ref val2)).position;
						<positionInBetweenInAir>5__3 = (<positionBehindPlayer>5__2 + <positionBehindPlayer>5__2) / 2f + Vector3.up * 10f;
						<originalPosition>5__4 = ((Component)fromAmbushJumpPlayerState.self).transform.position;
						fromAmbushJumpPlayerState.Agent.speed = 0f;
						fromAmbushJumpPlayerState.self.AnimatorSetBool("isRunning", value: true);
						((Behaviour)fromAmbushJumpPlayerState.Agent).enabled = false;
						<normalizedTimer>5__5 = 0f;
						break;
					}
					ca