using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Resources;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BoneLib;
using Il2CppInterop.Runtime.InteropTypes.Arrays;
using Il2CppSLZ.Marrow.Interaction;
using Il2CppSLZ.Marrow.SceneStreaming;
using MelonLoader;
using Microsoft.CodeAnalysis;
using NeighborLab;
using NeighborLab.AI;
using UnityEngine;
using UnityEngine.AI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: MelonInfo(typeof(Core), "NeighborLab", "0.2.1", "Elijoe", null)]
[assembly: MelonGame("Stress Level Zero", "BONELAB")]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = ".NET 6.0")]
[assembly: AssemblyCompany("NeighborLab")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+a735171592de38c3dda4d52e4619369e93069082")]
[assembly: AssemblyProduct("NeighborLab")]
[assembly: AssemblyTitle("NeighborLab")]
[assembly: NeutralResourcesLanguage("en-US")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[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;
		}
	}
}
[RegisterTypeInIl2Cpp]
public class KeyPoint : MonoBehaviour
{
	public float likelyHood;

	public int amountGone;

	public bool beenToThisLife;

	public KeyPoint(IntPtr intPtr)
		: base(intPtr)
	{
	}

	private void OnTriggerEnter(Collider other)
	{
		if (((Component)other.attachedRigidbody).gameObject.layer == 8)
		{
			beenToThisLife = true;
		}
	}
}
[RegisterTypeInIl2Cpp]
public class PlayerTeleporter : MonoBehaviour
{
	public PlayerTeleporter(IntPtr intPtr)
		: base(intPtr)
	{
	}

	public void TeleportPlayer(Transform position)
	{
		//IL_0013: Unknown result type (might be due to invalid IL or missing references)
		//IL_0019: Unknown result type (might be due to invalid IL or missing references)
		Player.PhysicsRig.ResetHands((Handedness)3);
		Player.RigManager.Teleport(position.position, position.forward, true);
	}
}
[RegisterTypeInIl2Cpp]
public class PointManager : MonoBehaviour
{
	public static PointManager instance;

	public int DeathAmount;

	public KeyPoint[] keyPoints;

	public List<KeyPoint> mostLikely = new List<KeyPoint>();

	public PointManager(IntPtr intPtr)
		: base(intPtr)
	{
	}

	private void Start()
	{
		instance = this;
		keyPoints = Il2CppArrayBase<KeyPoint>.op_Implicit(Object.FindObjectsOfType<KeyPoint>());
	}

	private void Update()
	{
	}

	public void OnPlayerCaught()
	{
		DeathAmount++;
		KeyPoint[] array = keyPoints;
		foreach (KeyPoint keyPoint in array)
		{
			if (keyPoint.beenToThisLife)
			{
				keyPoint.amountGone++;
			}
			keyPoint.likelyHood = keyPoint.amountGone / DeathAmount;
		}
		float num = 0f;
		KeyPoint[] array2 = keyPoints;
		foreach (KeyPoint keyPoint2 in array2)
		{
			if (keyPoint2.likelyHood == num)
			{
				mostLikely.Add(keyPoint2);
			}
			if (keyPoint2.likelyHood > num)
			{
				mostLikely.Clear();
				mostLikely.Add(keyPoint2);
			}
		}
	}
}
namespace NeighborLab
{
	public class Core : MelonMod
	{
		public override void OnInitializeMelon()
		{
			((MelonBase)this).LoggerInstance.Msg("Initialized.");
		}
	}
	[RegisterTypeInIl2Cpp]
	public class Door : MonoBehaviour
	{
		[CompilerGenerated]
		private sealed class <NeighborOpen>d__17 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public Door <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b3: Expected O, but got Unknown
				//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
				//IL_007d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0087: Expected O, but got Unknown
				//IL_0102: Unknown result type (might be due to invalid IL or missing references)
				//IL_010c: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					if (!<>4__this.locked)
					{
						<>4__this.closed = false;
						<>4__this.lockJoint.angularZMotion = (ConfigurableJointMotion)1;
						<>4__this.neighborOpen = true;
						<>2__current = (object)new WaitForSeconds(0.1f);
						<>1__state = 1;
						return true;
					}
					break;
				case 1:
					<>1__state = -1;
					<>4__this.neighborOpen = false;
					<>2__current = (object)new WaitForSeconds(2f);
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					if (!(Quaternion.Angle(<>4__this.defaultDoorRot, <>4__this.door.localRotation) <= 2f))
					{
						<>4__this.neighborClose = true;
					}
					<>2__current = (object)new WaitForSeconds(2f);
					<>1__state = 3;
					return true;
				case 3:
					<>1__state = -1;
					<>4__this.neighborClose = false;
					break;
				}
				return false;
			}

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

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

		public Transform handle;

		public Transform door;

		public ConfigurableJoint lockJoint;

		public Quaternion defaultDoorRot;

		public Quaternion defaultHandleRot;

		private bool neighborOpen;

		private bool neighborClose;

		private bool doorHandlePushed;

		public bool closed;

		public bool locked;

		public List<DoorLocks> doorLocks = new List<DoorLocks>();

		public Door(IntPtr intPtr)
			: base(intPtr)
		{
		}

		private void Awake()
		{
		}

		private void Start()
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			defaultDoorRot = door.localRotation;
			defaultHandleRot = handle.localRotation;
			doorLocks = new List<DoorLocks>();
		}

		public void SetUpDoorLocks(DoorLocks locker)
		{
			MelonLogger.Msg("Door lock");
			doorLocks.Add(locker);
			locker.door = this;
		}

		private void Update()
		{
			//IL_0017: 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_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: 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_00d1: Unknown result type (might be due to invalid IL or missing references)
			locked = doorLocks.Count > 0;
			doorHandlePushed = Quaternion.Angle(defaultHandleRot, handle.localRotation) >= 30f;
			if (locked && !closed)
			{
				CloseDoor();
			}
			if (doorHandlePushed && !locked && closed)
			{
				OpenDoor();
			}
			if (neighborClose)
			{
				door.rotation = Quaternion.Lerp(door.rotation, defaultDoorRot, 0.1f);
			}
			if (!doorHandlePushed && !closed && Quaternion.Angle(defaultDoorRot, door.localRotation) <= 2f && !neighborOpen)
			{
				neighborClose = false;
				CloseDoor();
			}
		}

		public void OpenDoor()
		{
			if (!locked)
			{
				closed = false;
				lockJoint.angularZMotion = (ConfigurableJointMotion)1;
			}
		}

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

		public void CloseDoor()
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			closed = true;
			door.localRotation = defaultDoorRot;
			lockJoint.angularZMotion = (ConfigurableJointMotion)0;
		}

		public void SetUp(Transform Handle, Transform Door, ConfigurableJoint LockJoint)
		{
			handle = Handle;
			door = Door;
			lockJoint = LockJoint;
		}
	}
	[RegisterTypeInIl2Cpp]
	public class DoorLocks : MonoBehaviour
	{
		public Door door;

		public DoorLocks(IntPtr intPtr)
			: base(intPtr)
		{
		}

		public void Unlock()
		{
			door.doorLocks.Remove(this);
		}
	}
	[RegisterTypeInIl2Cpp]
	public class NeighborMusic : MonoBehaviour
	{
		private GameObject chase;

		private GameObject catching;

		private Neighbor neighbor;

		public NeighborMusic(IntPtr intPtr)
			: base(intPtr)
		{
		}

		private void Awake()
		{
			neighbor = ((Component)this).GetComponent<Neighbor>();
		}

		public void setUpChase(GameObject Chase)
		{
			chase = Chase;
		}

		public void setUpCatch(GameObject value)
		{
			catching = value;
		}

		private void Update()
		{
			chase.SetActive(neighbor.alertState == NeighborState.Chase);
			if (neighbor.alertState == NeighborState.Catching && !catching.GetComponent<AudioSource>().isPlaying)
			{
				catching.GetComponent<AudioSource>().Play();
			}
		}
	}
}
namespace NeighborLab.AI
{
	[RegisterTypeInIl2Cpp]
	public class Distraction : MonoBehaviour
	{
		public bool activated;

		public float range;

		private Neighbor neighbor;

		private Animator animator;

		public Distraction(IntPtr intPtr)
			: base(intPtr)
		{
		}

		private void Start()
		{
			try
			{
				neighbor = Neighbor.singleton;
			}
			catch
			{
			}
		}

		public void setUp(float Range, Animator Animator)
		{
			animator = Animator;
			range = Range;
		}

		public void setUp(float Range)
		{
			range = Range;
		}

		public void toggleActive()
		{
			activated = !activated;
		}

		private void Update()
		{
			//IL_006f: 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)
			try
			{
				animator.SetBool("Active", activated);
			}
			catch
			{
			}
			try
			{
				if ((Object)(object)neighbor == (Object)null)
				{
					neighbor = Neighbor.singleton;
				}
			}
			catch
			{
				return;
			}
			if (!((Object)(object)neighbor == (Object)null) && activated && Vector3.Distance(((Component)neighbor).transform.position, ((Component)this).transform.position) <= range)
			{
				neighbor.Distract(this);
			}
		}

		private void OnDrawGizmosSelected()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			Gizmos.DrawWireSphere(((Component)this).transform.position, range);
		}
	}
	[RegisterTypeInIl2Cpp]
	public class Neighbor : MonoBehaviour
	{
		[CompilerGenerated]
		private sealed class <Catch>d__35 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public Neighbor <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0080: Unknown result type (might be due to invalid IL or missing references)
				//IL_008a: Expected O, but got Unknown
				//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c0: Expected O, but got Unknown
				//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>4__this.alertState = NeighborState.Catching;
					<>4__this.movementState = MovementState.Catching;
					<>4__this.searching = false;
					((Behaviour)<>4__this.agent).enabled = false;
					((Collider)Player.PhysicsRig._football).attachedRigidbody.isKinematic = true;
					<>2__current = (object)new WaitForSeconds(1f);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					((Collider)Player.PhysicsRig._football).attachedRigidbody.isKinematic = false;
					<>2__current = (object)new WaitForSeconds(0.5f);
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					Player.PhysicsRig.ResetHands((Handedness)3);
					Player.RigManager.Teleport(((Component)<>4__this.playerMarker).transform.position, true);
					Player.PhysicsRig.TurnOnRig();
					<>4__this.alertState = NeighborState.Chill;
					<>4__this.movementState = MovementState.Walking;
					<>4__this.knockedCountdown = 0f;
					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 <EndTask>d__38 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public Neighbor <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				//IL_005b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0065: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>4__this.performingTask = false;
					<>4__this.neighborAnimator.ForceToIdle();
					if (!<>4__this.neighborLineOfSight.canSeePlayer)
					{
						<>2__current = (object)new WaitForSeconds(2.5f);
						<>1__state = 1;
						return true;
					}
					break;
				case 1:
					<>1__state = -1;
					break;
				}
				<>4__this.movementState = MovementState.Walking;
				<>4__this.neighborLineOfSight.blind = false;
				<>4__this.lastTask = <>4__this.currentTask;
				<>4__this.currentTask.OnEnd();
				<>4__this.currentTask = null;
				<>4__this.remainingTaskTime = 0f;
				return false;
			}

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

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

		public static Neighbor singleton;

		public NeighborState alertState;

		public MovementState movementState;

		public float baseSpeed = 1.5f;

		public float runSpeed = 4f;

		public Task currentTask;

		private Task lastTask;

		public bool performingTask;

		private Distraction currentDistraction;

		private List<Distraction> distractions = new List<Distraction>();

		private TaskManager taskManager;

		private float remainingTaskTime;

		private NavMeshAgent agent;

		private NeighborAnimator neighborAnimator;

		private Vector3 lastKnownPlayerPosition;

		private Vector3 lastKnownPlayerVel;

		private NeighborLineOfSight neighborLineOfSight;

		private PlayerMarker playerMarker;

		private List<KeyPoint> pointsSearched = new List<KeyPoint>();

		private KeyPoint nearestLikelyPoint;

		private KeyPoint currentSearch;

		private float searchCountdown;

		private float searchTime = 2f;

		public bool searching;

		public bool canChase = true;

		private float knockedTime = 4.5f;

		private float knockedCountdown;

		public Neighbor(IntPtr intPtr)
			: base(intPtr)
		{
		}

		private void Start()
		{
			agent = ((Component)this).GetComponent<NavMeshAgent>();
			singleton = this;
			taskManager = TaskManager.instance;
			neighborAnimator = ((Component)this).GetComponent<NeighborAnimator>();
			neighborLineOfSight = ((Component)this).GetComponent<NeighborLineOfSight>();
			playerMarker = Object.FindObjectOfType<PlayerMarker>();
		}

		public void CanChase(bool value)
		{
			canChase = value;
		}

		private void Update()
		{
			if (neighborLineOfSight.canSeePlayer)
			{
			}
			if (neighborLineOfSight.canSeePlayer && alertState != NeighborState.Catching)
			{
				alertState = NeighborState.Chase;
				searching = false;
			}
			if (!canChase && alertState == NeighborState.Chase)
			{
				alertState = NeighborState.Chill;
			}
			if (knockedCountdown > 0f)
			{
				knockedCountdown -= Time.deltaTime;
			}
			else if (movementState == MovementState.KnockedOver)
			{
				movementState = MovementState.Running;
				if (alertState != NeighborState.Chase)
				{
					alertState = NeighborState.Alert;
				}
			}
			switch (movementState)
			{
			case MovementState.Walking:
				((Behaviour)agent).enabled = true;
				agent.speed = baseSpeed;
				DoorCheck();
				break;
			case MovementState.Running:
				((Behaviour)agent).enabled = true;
				agent.speed = runSpeed;
				DoorCheck();
				break;
			case MovementState.Idle:
				((Behaviour)agent).enabled = false;
				break;
			case MovementState.Task:
				((Behaviour)agent).enabled = false;
				break;
			case MovementState.KnockedOver:
				((Behaviour)agent).enabled = false;
				break;
			}
			switch (alertState)
			{
			case NeighborState.Chill:
				Chillin();
				break;
			case NeighborState.Alert:
				if ((Object)(object)currentDistraction != (Object)null)
				{
					Distracted();
				}
				else
				{
					Hunt();
				}
				break;
			case NeighborState.Chase:
				Chase();
				break;
			}
		}

		private void DoorCheck()
		{
			//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_001d: 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_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			Vector3 position = ((Component)this).transform.position;
			position.y += 1f;
			RaycastHit val = default(RaycastHit);
			if (Physics.Raycast(position, ((Component)this).transform.forward, ref val, 1f, 951377) && !((Object)(object)((RaycastHit)(ref val)).rigidbody == (Object)null))
			{
				Door componentInParent = ((Component)((RaycastHit)(ref val)).rigidbody).GetComponentInParent<Door>();
				if (!((Object)(object)componentInParent == (Object)null))
				{
					MelonCoroutines.Start(componentInParent.NeighborOpen());
					((RaycastHit)(ref val)).rigidbody.AddForce(((Component)this).transform.forward * 25f);
				}
			}
		}

		private void Chillin()
		{
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)currentTask == (Object)null)
			{
				if (performingTask)
				{
					EndTask();
				}
				FindTask();
			}
			else if (performingTask)
			{
				PerformTask();
			}
			else
			{
				SetDestination(((Component)currentTask).transform.position);
				if ((double)Vector3.Distance(((Component)currentTask).transform.position, ((Component)this).transform.position) <= 0.1)
				{
					StartTask();
				}
			}
		}

		private void Chase()
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: Unknown result type (might be due to invalid IL or missing references)
			//IL_0126: Unknown result type (might be due to invalid IL or missing references)
			movementState = MovementState.Running;
			if (Vector3.Distance(((Component)this).transform.position, neighborLineOfSight.playerRef.transform.position) <= 2f)
			{
				MelonCoroutines.Start(Catch());
			}
			if (performingTask)
			{
				EndTask();
			}
			if (neighborLineOfSight.canSeePlayer)
			{
				lastKnownPlayerPosition = neighborLineOfSight.playerRef.transform.position;
				lastKnownPlayerVel = ((Collider)Player.PhysicsRig._football).attachedRigidbody.velocity;
				SetDestination(lastKnownPlayerPosition);
			}
			else
			{
				SetDestination(lastKnownPlayerPosition + lastKnownPlayerVel);
				if (Vector3.Distance(((Component)this).transform.position, lastKnownPlayerPosition + lastKnownPlayerVel) <= 0.5f && alertState != NeighborState.Catching)
				{
					alertState = NeighborState.Alert;
				}
			}
			if (Vector3.Distance(((Component)this).transform.position, lastKnownPlayerPosition + lastKnownPlayerVel) <= 0.5f && alertState != NeighborState.Catching)
			{
				alertState = NeighborState.Alert;
			}
		}

		private void Hunt()
		{
			//IL_02dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0200: Unknown result type (might be due to invalid IL or missing references)
			//IL_0210: Unknown result type (might be due to invalid IL or missing references)
			//IL_0220: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)PointManager.instance == (Object)null)
			{
				MelonLogger.Error("PointManager doesnt exist!");
				return;
			}
			if (PointManager.instance.keyPoints.Count() == 0)
			{
				MelonLogger.Error("No keypoints!");
				return;
			}
			if ((Object)(object)currentSearch == (Object)null)
			{
				if (PointManager.instance.mostLikely.Count == 0)
				{
					KeyPoint[] keyPoints = PointManager.instance.keyPoints;
					foreach (KeyPoint keyPoint in keyPoints)
					{
						if (pointsSearched.Count == 0 || !pointsSearched.Contains(keyPoint))
						{
							if ((Object)(object)nearestLikelyPoint == (Object)null)
							{
								nearestLikelyPoint = keyPoint;
							}
							if (Vector3.Distance(((Component)this).transform.position, ((Component)keyPoint).transform.position) < Vector3.Distance(((Component)this).transform.position, ((Component)nearestLikelyPoint).transform.position))
							{
								nearestLikelyPoint = keyPoint;
							}
						}
					}
					if ((Object)(object)nearestLikelyPoint == (Object)null && alertState != NeighborState.Catching)
					{
						alertState = NeighborState.Chill;
						currentSearch = null;
						pointsSearched.Clear();
					}
					currentSearch = nearestLikelyPoint;
					pointsSearched.Add(currentSearch);
				}
				else
				{
					foreach (KeyPoint item in PointManager.instance.mostLikely)
					{
						if (!pointsSearched.Contains(item))
						{
							if ((Object)(object)nearestLikelyPoint == (Object)null)
							{
								nearestLikelyPoint = item;
							}
							if (Vector3.Distance(((Component)this).transform.position, ((Component)item).transform.position) < Vector3.Distance(((Component)this).transform.position, ((Component)nearestLikelyPoint).transform.position))
							{
								nearestLikelyPoint = item;
							}
						}
					}
					if ((Object)(object)nearestLikelyPoint == (Object)null && alertState != NeighborState.Catching)
					{
						alertState = NeighborState.Chill;
						currentSearch = null;
						pointsSearched.Clear();
					}
					currentSearch = nearestLikelyPoint;
					pointsSearched.Add(currentSearch);
				}
			}
			if ((Object)(object)currentSearch == (Object)null)
			{
				return;
			}
			SetDestination(((Component)currentSearch).transform.position);
			if (Vector3.Distance(((Component)this).transform.position, ((Component)currentSearch).transform.position) <= 2.5f)
			{
				if (!searching)
				{
					searching = true;
					movementState = MovementState.Idle;
					searchCountdown = searchTime;
				}
				else if (searchCountdown <= 0f)
				{
					searching = false;
					currentSearch = null;
					movementState = MovementState.Running;
					nearestLikelyPoint = null;
				}
				searchCountdown -= Time.deltaTime;
			}
		}

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

		private void StartTask()
		{
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			remainingTaskTime = Random.Range(currentTask.timeRange.x, currentTask.timeRange.y);
			movementState = MovementState.Task;
			if (!currentTask.canSeeDuring)
			{
				neighborLineOfSight.blind = true;
			}
			neighborAnimator.TaskAnim(currentTask.animation);
			if (currentTask.setTransform)
			{
				((Component)this).transform.position = ((Component)currentTask).transform.position;
				((Component)this).transform.rotation = ((Component)currentTask).transform.rotation;
			}
			currentTask.OnStart();
			performingTask = true;
		}

		private void PerformTask()
		{
			if (remainingTaskTime <= 0f)
			{
				MelonCoroutines.Start(EndTask());
				return;
			}
			movementState = MovementState.Task;
			remainingTaskTime -= Time.deltaTime;
		}

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

		private void FindTask()
		{
			currentTask = taskManager.tasks[Random.Range(0, taskManager.tasks.Length)];
			if ((Object)(object)currentTask == (Object)(object)lastTask)
			{
				currentTask = null;
			}
		}

		private void Distracted()
		{
			//IL_0015: 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_005e: Unknown result type (might be due to invalid IL or missing references)
			alertState = NeighborState.Alert;
			movementState = MovementState.Running;
			if (Vector3.Distance(((Component)this).transform.position, ((Component)currentDistraction).transform.position) <= 2f)
			{
				currentDistraction.activated = false;
				currentDistraction = null;
			}
			SetDestination(((Component)currentDistraction).transform.position);
		}

		private void SetDestination(Vector3 position)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: 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)
			NavMeshHit val = default(NavMeshHit);
			if (!NavMesh.SamplePosition(position, ref val, 5f, -1))
			{
				NavMeshHit val2 = default(NavMeshHit);
				NavMesh.FindClosestEdge(position, ref val2, -1);
				agent.destination = ((NavMeshHit)(ref val2)).position;
			}
			else
			{
				agent.destination = position;
			}
		}

		public void Distract(Distraction distraction)
		{
			if (!isDistractedBy(distraction))
			{
				alertState = NeighborState.Alert;
				if ((Object)(object)currentDistraction == (Object)null)
				{
					currentDistraction = distraction;
				}
				else
				{
					distractions.Add(distraction);
				}
			}
		}

		public bool isDistractedBy(Distraction distraction)
		{
			return distractions.Contains(distraction) || (Object)(object)currentDistraction == (Object)(object)distraction;
		}

		private void KnockOver()
		{
			movementState = MovementState.KnockedOver;
			knockedCountdown = knockedTime;
		}

		private void OnCollisionEnter(Collision collision)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			Vector3 relativeVelocity = collision.relativeVelocity;
			if (((Vector3)(ref relativeVelocity)).magnitude >= 5f && (Object)(object)((Component)((Component)collision.rigidbody).GetComponent<MarrowBody>().Entity).GetComponent<Door>() == (Object)null)
			{
				KnockOver();
			}
		}
	}
	public enum NeighborState
	{
		Chill,
		Alert,
		Chase,
		Catching
	}
	public enum MovementState
	{
		Walking,
		Running,
		Idle,
		Task,
		Catching,
		KnockedOver
	}
	[RegisterTypeInIl2Cpp]
	public class NeighborAnimator : MonoBehaviour
	{
		private Animator animator;

		private Neighbor neighbor;

		private NeighborLineOfSight neighborLineOfSight;

		public NeighborAnimator(IntPtr intPtr)
			: base(intPtr)
		{
		}

		private void Start()
		{
			animator = ((Component)this).GetComponentInChildren<Animator>();
			neighbor = ((Component)this).GetComponent<Neighbor>();
			neighborLineOfSight = ((Component)this).GetComponent<NeighborLineOfSight>();
		}

		private void Update()
		{
			animator.SetInteger("MoveState", (int)neighbor.movementState);
			animator.SetBool("CanSeePlayer", neighborLineOfSight.canSeePlayer);
			animator.SetBool("Search", neighbor.searching);
		}

		public void ForceToIdle()
		{
			animator.SetTrigger("ForceReset");
		}

		public bool isInTaskAnim()
		{
			return animator.GetCurrentStateName(0) == "Tasks";
		}

		public void TaskAnim(AnimationClip clip)
		{
			animator.Play(((Object)clip).name);
		}
	}
	[RegisterTypeInIl2Cpp]
	public class NeighborLineOfSight : MonoBehaviour
	{
		[CompilerGenerated]
		private sealed class <FOVRoutine>d__14 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public NeighborLineOfSight <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0083: Unknown result type (might be due to invalid IL or missing references)
				//IL_008d: Expected O, but got Unknown
				//IL_004f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0059: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					break;
				case 1:
					<>1__state = -1;
					<>4__this.angle = 90f;
					goto IL_00ae;
				case 2:
					{
						<>1__state = -1;
						<>4__this.angle = 170f;
						goto IL_00ae;
					}
					IL_00ae:
					if (!<>4__this.blind)
					{
						<>4__this.FieldOfViewCheck();
					}
					break;
				}
				if (<>4__this.neighbor.alertState == NeighborState.Chill)
				{
					<>2__current = (object)new WaitForSeconds(1f);
					<>1__state = 1;
					return true;
				}
				<>2__current = (object)new WaitForSeconds(0.2f);
				<>1__state = 2;
				return true;
			}

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

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

		public float radius = 30f;

		public float angle = 170f;

		public GameObject playerRef;

		public LayerMask targetMask = LayerMask.op_Implicit(16777472);

		public LayerMask obstructionMask = LayerMask.op_Implicit(951377);

		public Transform localPlayerHead;

		public bool blind = true;

		public bool canSeePlayer;

		private Transform playerHead;

		private Transform eyePos;

		private Neighbor neighbor;

		public NeighborLineOfSight(IntPtr intPtr)
			: base(intPtr)
		{
		}//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_002c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0031: Unknown result type (might be due to invalid IL or missing references)


		public void SetUp(Transform EyePos)
		{
			eyePos = EyePos;
		}

		private void Start()
		{
			neighbor = ((Component)this).GetComponent<Neighbor>();
			MelonCoroutines.Start(FOVRoutine());
		}

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

		private void FieldOfViewCheck()
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)playerHead == (Object)null)
			{
				playerHead = Player.Head;
				MelonLogger.Msg("Player Head Missing!");
				return;
			}
			Collider[] array = Il2CppArrayBase<Collider>.op_Implicit((Il2CppArrayBase<Collider>)(object)Physics.OverlapSphere(eyePos.position, radius, LayerMask.op_Implicit(targetMask)));
			if (array.Length != 0)
			{
				Transform val = playerHead;
				Vector3 val2 = val.position - eyePos.position;
				Vector3 normalized = ((Vector3)(ref val2)).normalized;
				if (Vector3.Angle(eyePos.forward, normalized) <= angle / 2f)
				{
					float num = Vector3.Distance(eyePos.position, val.position);
					RaycastHit val3 = default(RaycastHit);
					if (!Physics.Raycast(eyePos.position, normalized, ref val3, num, LayerMask.op_Implicit(obstructionMask)))
					{
						canSeePlayer = true;
						playerRef = ((Component)val).gameObject;
					}
					else if (((Component)((RaycastHit)(ref val3)).collider).gameObject.layer == 8)
					{
						canSeePlayer = true;
						playerRef = ((Component)val).gameObject;
					}
					else
					{
						canSeePlayer = false;
					}
				}
				else
				{
					canSeePlayer = false;
				}
			}
			else if (canSeePlayer)
			{
				canSeePlayer = false;
			}
		}
	}
	[RegisterTypeInIl2Cpp]
	public class Task : MonoBehaviour
	{
		public AnimationClip animation;

		public Vector2 timeRange;

		public bool setTransform;

		public bool canSeeDuring = true;

		public GameObject events;

		public Task(IntPtr intPtr)
			: base(intPtr)
		{
		}

		public void SetUp(AnimationClip Animation, Vector2 TimeRange, bool SetTransform)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			animation = Animation;
			timeRange = TimeRange;
			setTransform = SetTransform;
		}

		public void OnStart()
		{
			if (!((Object)(object)events == (Object)null))
			{
				events.SetActive(true);
			}
		}

		public void OnEnd()
		{
			if (!((Object)(object)events == (Object)null))
			{
				events.SetActive(false);
			}
		}

		public void SetUpEvents(GameObject Events)
		{
			events = Events;
		}

		private void Start()
		{
		}

		private void Update()
		{
		}

		public void CanSeeDuring(bool value)
		{
			canSeeDuring = value;
		}
	}
	[RegisterTypeInIl2Cpp]
	public class TaskManager : MonoBehaviour
	{
		public static TaskManager instance;

		public Task[] tasks;

		public TaskManager(IntPtr intPtr)
			: base(intPtr)
		{
		}

		private void Awake()
		{
			instance = this;
		}

		private void Start()
		{
			tasks = Il2CppArrayBase<Task>.op_Implicit(Object.FindObjectsOfType<Task>());
		}
	}
}