using System;
using System.CodeDom.Compiler;
using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using GameNetcodeStuff;
using HarmonyLib;
using HarmonyLib.Tools;
using Unity.Netcode;
using UnityEngine;
using UnityEngine.AI;
using UnityEngine.Animations.Rigging;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyVersion("0.0.0.0")]
internal class <Module>
{
	static <Module>()
	{
	}
}
public class HitboxScript : MonoBehaviour
{
	private static ManualLogSource Logger = Plugin.Logger;

	private int logLevel;

	[Header("Manager")]
	public bool isManager;

	public EnemyAI mainScript;

	public HitboxScript[] allHitboxes;

	[Space(3f)]
	[Header("Hitbox")]
	public Collider hitboxCollider;

	public int attackPower;

	public Vector3 attackForce;

	public int deathAnimIndex;

	public HitboxScript managerHitbox;

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

	private void Start()
	{
		logLevel = Plugin.DebugLogLevel();
		if (!isManager)
		{
			return;
		}
		managerHitbox = this;
		HitboxScript[] array = allHitboxes;
		foreach (HitboxScript hitboxScript in array)
		{
			hitboxScript.hitboxCollider.enabled = false;
			hitboxScript.managerHitbox = this;
			if ((Object)(object)mainScript != (Object)null)
			{
				hitboxScript.mainScript = mainScript;
			}
			else
			{
				Log(((Object)hitboxScript).name + " started without mainTransform, using own transform to calculate directions and cannot play punch SFX", 2);
			}
		}
	}

	private void OnTriggerEnter(Collider other)
	{
		PerformAttackOnHitbox(other);
	}

	private void PerformAttackOnHitbox(Collider other)
	{
		//IL_0066: 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_00c3: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
		//IL_016f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0175: Unknown result type (might be due to invalid IL or missing references)
		//IL_017a: Unknown result type (might be due to invalid IL or missing references)
		if (!((Component)other).CompareTag("Player"))
		{
			return;
		}
		PlayerControllerB component = ((Component)other).GetComponent<PlayerControllerB>();
		if (!PerformHitPlayerCheck(component) || !((Object)(object)component == (Object)(object)GameNetworkManager.Instance.localPlayerController))
		{
			return;
		}
		Log($"{((Object)this).name} PerformAttack({other}) // hitPlayer: {component} | attackPower {attackPower} | attackForce {attackForce}");
		Transform val = (((Object)(object)mainScript != (Object)null) ? ((Component)mainScript).transform : ((Component)this).transform);
		Vector3 val2 = default(Vector3);
		((Vector3)(ref val2))..ctor(val.forward.x * attackForce.z, attackForce.y, val.forward.z * attackForce.x);
		if (attackPower > 0)
		{
			component.DamagePlayer(attackPower, true, true, (CauseOfDeath)6, deathAnimIndex, false, val2);
		}
		if (component.isPlayerDead)
		{
			if ((Object)(object)mainScript == (Object)null)
			{
				Log("mainScript on hitbox " + ((Object)this).name + " is null, cannot call enemy-dependent functionality", 2);
			}
			else if (mainScript is TheBeatAI)
			{
				_ = mainScript;
			}
			else if (mainScript is TheBoxerAI)
			{
				TheBoxerAI obj = mainScript as TheBoxerAI;
				obj.PlaySFX(obj.punchSFX);
			}
		}
		else
		{
			component.externalForceAutoFade = val2 * 2f;
		}
	}

	private bool PerformHitPlayerCheck(PlayerControllerB hitPlayer)
	{
		if ((Object)(object)hitPlayer == (Object)null || !hitPlayer.isPlayerControlled)
		{
			return false;
		}
		int item = (int)hitPlayer.playerClientId;
		bool num = !hitPlayerIDs.Contains(item);
		if (num)
		{
			hitPlayerIDs.Add(item);
			if (!managerHitbox.hitPlayerIDs.Contains(item))
			{
				managerHitbox.hitPlayerIDs.Add(item);
			}
		}
		return num;
	}

	public void SetEnemyVulnerable(string setVulnerableTo)
	{
		if ((Object)(object)mainScript == (Object)null)
		{
			Log("called SetEnemyVulnerable on " + ((Object)this).name + " with null mainScript", 2);
			return;
		}
		LogAI($"{((Object)this).name}: SetEnemyVulnerable({setVulnerableTo}) on {mainScript} #{((NetworkBehaviour)mainScript).NetworkObjectId}");
		if (mainScript is TheBeatAI)
		{
			_ = mainScript;
		}
		else if (mainScript is TheBoxerAI)
		{
			TheBoxerAI theBoxerAI = mainScript as TheBoxerAI;
			if ((Object)(object)theBoxerAI != (Object)null)
			{
				theBoxerAI.SetEnemyVulnerable(Plugin.ConvertToBool(setVulnerableTo));
			}
		}
	}

	public void SetEnemyInSpecialAnimTo(string setInSpecialAnimationTo)
	{
		if ((Object)(object)mainScript == (Object)null)
		{
			Log("called SetEnemyInSpecialAnimTo on " + ((Object)this).name + " with null mainScript", 2);
			return;
		}
		LogAI($"{((Object)this).name}: PlayEnemyInSpecialAnimTo({setInSpecialAnimationTo}) on {mainScript} #{((NetworkBehaviour)mainScript).NetworkObjectId}");
		if (mainScript is TheBeatAI)
		{
			_ = mainScript;
		}
		else if (mainScript is TheBoxerAI)
		{
			(mainScript as TheBoxerAI).SetEnemyInSpecialAnimation(Plugin.ConvertToBool(setInSpecialAnimationTo));
		}
	}

	public void OnAttackStart()
	{
		if ((Object)(object)mainScript == (Object)null)
		{
			Log("called OnAttackStart on " + ((Object)this).name + " with null mainScript", 2);
			return;
		}
		Log(((Object)this).name + ": OnAttackStart()");
		managerHitbox.hitPlayerIDs.Clear();
		HitboxScript[] array = allHitboxes;
		foreach (HitboxScript hitboxScript in array)
		{
			LogAI($"clearing hitPlayerIDs on {hitboxScript}");
			hitboxScript.hitPlayerIDs.Clear();
		}
	}

	public void DisableAllHitboxes()
	{
		//IL_003c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0041: Unknown result type (might be due to invalid IL or missing references)
		LogAI("called DisableAllHitboxes on " + ((Object)this).name);
		if (isManager)
		{
			HitboxScript[] array = allHitboxes;
			foreach (HitboxScript obj in array)
			{
				obj.attackPower = 0;
				obj.deathAnimIndex = 0;
				obj.attackForce = Vector3.zero;
				obj.hitboxCollider.enabled = false;
			}
		}
	}

	public void PlaySFXOnEnemy(int clipCase)
	{
		if ((Object)(object)mainScript == (Object)null)
		{
			Log("called PlaySFXOnEnemy on " + ((Object)this).name + " with null mainScript", 2);
			return;
		}
		LogAI($"{((Object)this).name}: PlaySFXOnEnemy({clipCase}) on {mainScript} #{((NetworkBehaviour)mainScript).NetworkObjectId}");
		if (mainScript is TheBeatAI)
		{
			(mainScript as TheBeatAI).PlaySFX(null, audibleNoise: true, isAudience: false, sync: false, clipCase);
		}
		else if (mainScript is TheBoxerAI)
		{
			(mainScript as TheBoxerAI).PlaySFX(null, audibleNoise: true, isAudience: false, sync: false, clipCase);
		}
	}

	public void PlayAudienceOnEnemy(int clipCase)
	{
		if ((Object)(object)mainScript == (Object)null)
		{
			Log("called PlayAudienceOnEnemy on " + ((Object)this).name + " with null mainScript", 2);
			return;
		}
		LogAI($"{((Object)this).name}: PlayAudienceOnEnemy({clipCase}) on {mainScript} #{((NetworkBehaviour)mainScript).NetworkObjectId}");
		if (mainScript is TheBeatAI)
		{
			(mainScript as TheBeatAI).PlaySFX(null, audibleNoise: true, isAudience: true, sync: false, clipCase);
		}
		else if (mainScript is TheBoxerAI)
		{
			(mainScript as TheBoxerAI).PlaySFX(null, audibleNoise: true, isAudience: true, sync: false, clipCase);
		}
	}

	public void SpecialAnimEvent(int eventCase)
	{
		//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
		//IL_0159: Unknown result type (might be due to invalid IL or missing references)
		//IL_0169: Unknown result type (might be due to invalid IL or missing references)
		//IL_018a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0196: Unknown result type (might be due to invalid IL or missing references)
		//IL_019b: Unknown result type (might be due to invalid IL or missing references)
		//IL_01a5: Unknown result type (might be due to invalid IL or missing references)
		//IL_01aa: Unknown result type (might be due to invalid IL or missing references)
		//IL_01af: Unknown result type (might be due to invalid IL or missing references)
		//IL_01c0: Unknown result type (might be due to invalid IL or missing references)
		//IL_01ff: Unknown result type (might be due to invalid IL or missing references)
		//IL_0204: Unknown result type (might be due to invalid IL or missing references)
		//IL_0205: Unknown result type (might be due to invalid IL or missing references)
		//IL_020a: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)mainScript == (Object)null)
		{
			Log("called SpecialAnimEvent on " + ((Object)this).name + " with null mainScript", 2);
			return;
		}
		LogAI($"{((Object)this).name}: SpecialAnimEvent({eventCase}) on {mainScript} #{((NetworkBehaviour)mainScript).NetworkObjectId}");
		if (mainScript is TheBeatAI)
		{
			_ = mainScript;
		}
		else
		{
			if (!(mainScript is TheBoxerAI))
			{
				return;
			}
			TheBoxerAI theBoxerAI = mainScript as TheBoxerAI;
			switch (eventCase)
			{
			default:
				theBoxerAI.SetSpotlight(theBoxerAI.enemySpotlight, sync: false, enableLight: false);
				break;
			case 1:
				theBoxerAI.SpawnShovelAndSync();
				break;
			case 2:
				theBoxerAI.EndGiveShovelAnim();
				break;
			case 3:
			{
				mainScript.enemyType.canBeStunned = false;
				StunGrenadeItem.StunExplosion(((Component)mainScript).transform.position, true, 1f, 5f, 1f, false, (PlayerControllerB)null, (PlayerControllerB)null, 0f);
				mainScript.enemyType.canBeStunned = true;
				PlayerControllerB localPlayerController = StartOfRound.Instance.localPlayerController;
				if (!localPlayerController.isPlayerControlled || localPlayerController.isInsideFactory || (Object)(object)localPlayerController.inAnimationWithEnemy != (Object)null)
				{
					break;
				}
				float num = Vector3.Distance(((Component)localPlayerController).transform.position, ((Component)mainScript).transform.position);
				if (num > 10f)
				{
					break;
				}
				Vector3 val = mainScript.eye.forward * (num / 1.5f) + Vector3.up * 25f;
				if (num < 2f)
				{
					localPlayerController.DamagePlayer(10, true, true, (CauseOfDeath)3, 0, false, val);
					int item = (int)localPlayerController.playerClientId;
					if (!managerHitbox.hitPlayerIDs.Contains(item))
					{
						managerHitbox.hitPlayerIDs.Add(item);
					}
				}
				if (!localPlayerController.isPlayerDead)
				{
					localPlayerController.externalForceAutoFade += val;
				}
				break;
			}
			}
		}
	}

	public void CheckAttackHitOnManager()
	{
		if ((Object)(object)mainScript == (Object)null)
		{
			Log("called CheckAttackHitOnManager on " + ((Object)this).name + " with null mainScript", 2);
		}
		else if (mainScript is TheBeatAI)
		{
			_ = mainScript;
		}
		else
		{
			if (!(mainScript is TheBoxerAI))
			{
				return;
			}
			TheBoxerAI theBoxerAI = mainScript as TheBoxerAI;
			if ((Object)(object)theBoxerAI != (Object)null && ((NetworkBehaviour)theBoxerAI).IsOwner)
			{
				Log($"{theBoxerAI} hit {managerHitbox.hitPlayerIDs.Count}", 1);
				if (managerHitbox.hitPlayerIDs.Count != 0)
				{
					theBoxerAI.OnHitSuccessful(managerHitbox.hitPlayerIDs.ToArray());
				}
			}
		}
	}

	public void CheckAttackHit(int hitboxIndex)
	{
		if ((Object)(object)mainScript == (Object)null)
		{
			Log("called CheckAttackHit on " + ((Object)this).name + " with null mainScript", 2);
		}
		else if (hitboxIndex < 0 || hitboxIndex >= allHitboxes.Length)
		{
			Log($"called CheckAttackHitOnHitbox with invalid hitboxIndex {hitboxIndex}", 2);
		}
		else
		{
			allHitboxes[hitboxIndex].CheckAttackHitOnHitbox(mainScript);
		}
	}

	private void CheckAttackHitOnHitbox(EnemyAI enemyScript)
	{
		if (enemyScript is TheBeatAI || !(enemyScript is TheBoxerAI))
		{
			return;
		}
		TheBoxerAI theBoxerAI = enemyScript as TheBoxerAI;
		if ((Object)(object)theBoxerAI != (Object)null && ((NetworkBehaviour)theBoxerAI).IsOwner)
		{
			Log($"{theBoxerAI} hit {hitPlayerIDs.Count}", 1);
			if (hitPlayerIDs.Count != 0)
			{
				theBoxerAI.OnHitSuccessful(hitPlayerIDs.ToArray());
			}
		}
	}

	private void Log(string message, int type = 0)
	{
		if (logLevel >= 1)
		{
			switch (type)
			{
			case 0:
				Logger.LogDebug((object)message);
				break;
			case 1:
				Logger.LogInfo((object)message);
				break;
			case 2:
				Logger.LogWarning((object)message);
				break;
			case 3:
				Logger.LogError((object)message);
				break;
			}
		}
	}

	private void LogAI(string message, int type = 0)
	{
		if (logLevel >= 2)
		{
			switch (type)
			{
			case 0:
				Logger.LogDebug((object)message);
				break;
			case 1:
				Logger.LogInfo((object)message);
				break;
			case 2:
				Logger.LogWarning((object)message);
				break;
			case 3:
				Logger.LogError((object)message);
				break;
			}
		}
	}
}
[CreateAssetMenu(menuName = "LCBeatBoxerMod/DataContainers/Test/TestAttackAnimSequence")]
public class TestAttackAnimSequence : ScriptableObject
{
	public TestEnemyScript.AttackAnim[] attackAnimSequence;
}
public class TestCombatHitbox : MonoBehaviour
{
	private static ManualLogSource Logger = Plugin.Logger;

	public TestEnemyScript mainScript;

	public Collider hitbox;

	public int attackPower;

	public Vector3 attackForce;

	public int deathAnimIndex;

	[HideInInspector]
	public List<int> hitPlayerIDs = new List<int>();

	private void OnTriggerEnter(Collider other)
	{
		PerformAttack(other);
	}

	private void PerformAttack(Collider other)
	{
		//IL_006c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0098: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
		//IL_00de: Unknown result type (might be due to invalid IL or missing references)
		Logger.LogDebug((object)$"other: {other}");
		if (!((Component)other).CompareTag("Player"))
		{
			return;
		}
		PlayerControllerB component = ((Component)other).GetComponent<PlayerControllerB>();
		if (PerformHitPlayerCheck(component))
		{
			hitPlayerIDs.Add((int)component.playerClientId);
			Logger.LogDebug((object)$"hitPlayer: {component}");
			Vector3 val = default(Vector3);
			((Vector3)(ref val))..ctor(((Component)mainScript).transform.forward.x * attackForce.z, attackForce.y, ((Component)mainScript).transform.forward.z * attackForce.x);
			component.DamagePlayer(attackPower, true, true, (CauseOfDeath)6, deathAnimIndex, false, val);
			if (!component.isPlayerDead)
			{
				component.externalForceAutoFade = val * 2f;
			}
			mainScript.PlayAnimSFX(1);
		}
	}

	private bool PerformHitPlayerCheck(PlayerControllerB hitPlayer)
	{
		//IL_0052: Unknown result type (might be due to invalid IL or missing references)
		//IL_005d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0079: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)hitPlayer == (Object)null || !hitPlayer.isPlayerControlled || (Object)(object)hitPlayer != (Object)(object)StartOfRound.Instance.localPlayerController)
		{
			return false;
		}
		int item = (int)hitPlayer.playerClientId;
		bool flag = !hitPlayerIDs.Contains(item);
		if (flag)
		{
			Collider obj = hitbox;
			BoxCollider val = (BoxCollider)(object)((obj is BoxCollider) ? obj : null);
			float num = ((Component)this).transform.position.y - val.size.y / 2f - ((Component)hitPlayer.playerEye).transform.position.y;
			Logger.LogDebug((object)$"above head: {num}");
			if (num > 0.5f)
			{
				flag = false;
			}
			else
			{
				hitPlayerIDs.Add(item);
			}
		}
		return flag;
	}

	public void SetEnemyVulnerable(int setVulnerableTo)
	{
		mainScript.SetEnemyVulnerable(Plugin.ConvertToBool(setVulnerableTo));
	}

	public void SetEnemyInAttackAnimTo(int setInAttackAnimTo)
	{
		mainScript.SetEnemyInAttackAnimation(Plugin.ConvertToBool(setInAttackAnimTo));
	}

	public void ClearHitPlayerIDs()
	{
		Logger.LogDebug((object)("Clearing hitPlayerIDs on " + ((Object)this).name));
		hitPlayerIDs.Clear();
	}

	public void CheckAttackMiss()
	{
		if (((NetworkBehaviour)mainScript).IsOwner)
		{
			Logger.LogInfo((object)$"attack {mainScript.currentAttackTrigger} hit {hitPlayerIDs.Count}");
			if (hitPlayerIDs.Count == 0)
			{
				mainScript.currentAttackState = "Miss";
				mainScript.SetAnimation(mainScript.currentAttackTrigger + mainScript.currentAttackState);
			}
		}
	}
}
public class TestCombatHitboxAnimationEvents : MonoBehaviour
{
	public TestEnemyScript mainScript;

	public int currentHitboxIndex;

	public TestCombatHitbox[] allHitboxes;

	public void SetEnemyVulnerable(int setVulnerableTo)
	{
		mainScript.SetEnemyVulnerable(Plugin.ConvertToBool(setVulnerableTo));
	}

	public void SetEnemyInAttackAnimTo(int setEnemyInAttackAnimTo)
	{
		mainScript.SetEnemyInAttackAnimation(Plugin.ConvertToBool(setEnemyInAttackAnimTo));
	}

	public void PlayAnimSFXOnEnemy(int playCaseSFX)
	{
		mainScript.PlayAnimSFX(playCaseSFX);
	}

	public void ClearHitPlayerIDs()
	{
		allHitboxes[currentHitboxIndex].ClearHitPlayerIDs();
	}

	public void CheckAttackMiss()
	{
		allHitboxes[currentHitboxIndex].CheckAttackMiss();
	}
}
public class TestEnemyScript : EnemyAI
{
	public enum HideMode
	{
		InvalidNodesContains,
		PathIsIntersectedByLineOfSight,
		LessDistanceThanTargetPlayer
	}

	public enum NodeSelectionMode
	{
		DistanceAllPlayers,
		OnlyTargetPlayer,
		PrioritizeTargetPlayer
	}

	public enum VerticalOffsetMode
	{
		DontCalculate,
		RandomChance,
		IncreaseWithPower,
		DecreaseWithDivider
	}

	public enum AttackAnim
	{
		Headbutt,
		Punch,
		LowSweep
	}

	private static ManualLogSource Logger = Plugin.Logger;

	private float tempTimer;

	private bool setLureLocally;

	private bool waitingToSpawnLure;

	private Transform spawnLureAt;

	private Transform hideSpot;

	private bool reachedHideSpot;

	private Transform lastSeenAt;

	private Transform fleeToWhileCalculating;

	private Coroutine pickLurePositionCoroutine;

	private float lookingTime;

	private Vector3 lookingAt;

	private static List<Vector3> lastInvalidCorners = new List<Vector3>();

	private bool everyoneOutside;

	private float timeLastCollisionLocalPlayer;

	private bool seenDuringThisAmbush;

	private bool performedAmushAttack;

	[Space(3f)]
	[Header("CUSTOM")]
	public Item itemToSpawn;

	[HideInInspector]
	public EnemyLureTestItem linkedItem;

	public TestCombatHitbox hitboxScript;

	public Transform turnCompass;

	public Transform shovelParent;

	public MeshRenderer changeMatOf;

	public Material changeMatTo;

	[Space(3f)]
	[Header("COMBAT")]
	public bool inAttackAnimation;

	public bool vulnerable;

	public int currentAttackIndex;

	public string currentAttackTrigger;

	public string currentAttackState;

	public AttackAnim[] attackSequence;

	public TestAttackAnimSequence currentAttackSequence;

	public TestAttackAnimSequence[] testAttackAnimSequences;

	public static Item shovelItem;

	public GameObject spawnedShovel;

	public float attackCooldown;

	private float timeLastAttackAnimChange;

	[Space(3f)]
	[Header("SFX")]
	public AudioSource realAudio;

	public AudioClip footstepSFX;

	public AudioClip runSFX;

	public AudioClip blockSFX;

	public AudioClip intimidateSFX;

	public AudioClip reelSFX;

	public AudioClip punchSFX;

	public AudioClip bellSFX;

	[Space(3f)]
	[Header("SPEEDS")]
	public float roamSpeed;

	public float hideSpeed;

	public float chaseSpeed;

	[Space(3f)]
	[Header("SENSES")]
	public int seeDistance;

	public float seeWidth;

	public float awarenessDistance;

	public float noiseThreshold;

	[Range(0f, 1f)]
	public float noiseLookThreshold;

	public float noiseDistanceDropoffPower;

	[Space(3f)]
	[Header("PARAMETERS")]
	public bool randomizeNodeCheck;

	public float minDistanceBetweenFarawayNodes;

	public float maxDistanceBetweenFarawayNodes;

	public float maxPathBetweenFarawayNodes;

	public VerticalOffsetMode offsetMode;

	public AnimationCurve chanceToSkipOnVerticalOffset;

	public float verticalOffsetDropOffPower;

	public float verticalOffsetDropOffDivider;

	public float maxSearchDistance;

	public float maxLureSpawnTime;

	public float maxHideSpotTime;

	[Range(0f, 100f)]
	public int chanceToPlayFakeAudio;

	public HideMode hideMode;

	public float maxPlayerDistanceToHidePath;

	public NodeSelectionMode selectionMode;

	public int minNodesAbsolute;

	[Range(0f, 1f)]
	public float minNodesPercentage;

	public int[] statesDetectingNoise;

	public float attackDistanceThreshold;

	public float collisionCooldown;

	[Space(3f)]
	[Header("DEBUG")]
	public bool debugPrintBehaviourStateIndex;

	public bool debugSpawnLights;

	public GameObject debugNodeLightPrefab;

	public float debugIterationDelay;

	public bool debugCheckSeenPosToHide;

	public int debugMaxSearches;

	public bool debugInstantKillOnChase;

	public int debugTurnPlayerIterations;

	public override void Start()
	{
		//IL_000c: Unknown result type (might be due to invalid IL or missing references)
		base.enemyType.isOutsideEnemy = ((Component)this).transform.position.y > -50f;
		Logger.LogError((object)$"isOutside: {base.isOutside} | isOutsideEnemy: {base.enemyType.isOutsideEnemy}");
		((EnemyAI)this).Start();
		Logger.LogError((object)$"isOutside: {base.isOutside} | isOutsideEnemy: {base.enemyType.isOutsideEnemy}");
		lastInvalidCorners.Clear();
		if (((NetworkBehaviour)this).IsServer)
		{
			SpawnShovelAndSync();
		}
	}

	public override void Update()
	{
		//IL_008b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0028: Unknown result type (might be due to invalid IL or missing references)
		//IL_003e: Unknown result type (might be due to invalid IL or missing references)
		//IL_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_0068: Unknown result type (might be due to invalid IL or missing references)
		((EnemyAI)this).Update();
		if (!inAttackAnimation && Time.realtimeSinceStartup - lookingTime < 1f)
		{
			turnCompass.LookAt(lookingAt);
			((Component)this).transform.eulerAngles = new Vector3(((Component)this).transform.eulerAngles.x, turnCompass.eulerAngles.y, ((Component)this).transform.eulerAngles.z);
		}
		if (base.currentBehaviourStateIndex == 1 && StartOfRound.Instance.localPlayerController.HasLineOfSightToPosition(((Component)this).transform.position, 45f, 60, -1f))
		{
			StartOfRound.Instance.localPlayerController.IncreaseFearLevelOverTime(0.3f, 1f);
		}
		if (((NetworkBehaviour)this).IsOwner && (waitingToSpawnLure || (setLureLocally && (!reachedHideSpot || everyoneOutside)) || (base.currentBehaviourStateIndex == 2 && (Object)(object)base.targetPlayer == (Object)null)))
		{
			tempTimer += Time.deltaTime;
		}
	}

	public override void DoAIInterval()
	{
		//IL_039f: Unknown result type (might be due to invalid IL or missing references)
		//IL_03a5: Unknown result type (might be due to invalid IL or missing references)
		//IL_02ef: Unknown result type (might be due to invalid IL or missing references)
		//IL_0160: Unknown result type (might be due to invalid IL or missing references)
		//IL_0166: Unknown result type (might be due to invalid IL or missing references)
		//IL_03d8: Unknown result type (might be due to invalid IL or missing references)
		//IL_03f3: Unknown result type (might be due to invalid IL or missing references)
		//IL_0364: 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_04c2: Unknown result type (might be due to invalid IL or missing references)
		//IL_04d4: Unknown result type (might be due to invalid IL or missing references)
		//IL_04df: Unknown result type (might be due to invalid IL or missing references)
		//IL_0727: Unknown result type (might be due to invalid IL or missing references)
		//IL_0737: Unknown result type (might be due to invalid IL or missing references)
		//IL_01e2: Unknown result type (might be due to invalid IL or missing references)
		//IL_01ed: Unknown result type (might be due to invalid IL or missing references)
		//IL_0124: Unknown result type (might be due to invalid IL or missing references)
		//IL_012f: Unknown result type (might be due to invalid IL or missing references)
		//IL_05ed: Unknown result type (might be due to invalid IL or missing references)
		//IL_05fd: Unknown result type (might be due to invalid IL or missing references)
		//IL_04ae: Unknown result type (might be due to invalid IL or missing references)
		((EnemyAI)this).DoAIInterval();
		if (StartOfRound.Instance.allPlayersDead)
		{
			return;
		}
		if (debugPrintBehaviourStateIndex)
		{
			Logger.LogInfo((object)$"currentBehaviourStateIndex: [{base.currentBehaviourStateIndex}]");
		}
		switch (base.currentBehaviourStateIndex)
		{
		case 0:
			base.useSecondaryAudiosOnAnimatedObjects = false;
			if (setLureLocally)
			{
				if (base.currentSearch.inProgress)
				{
					Logger.LogDebug((object)"STOP search (0)");
					((EnemyAI)this).StopSearch(base.currentSearch, true);
				}
				if (!reachedHideSpot)
				{
					if ((Object)(object)hideSpot != (Object)null)
					{
						Logger.LogDebug((object)"going to HIDE");
						((EnemyAI)this).SetDestinationToPosition(hideSpot.position, false);
						base.agent.speed = hideSpeed;
						if (debugIterationDelay <= 0f && tempTimer > maxHideSpotTime)
						{
							Logger.LogError((object)"TIMER: Unable to reach hideSpot, pausing");
							OnReachHideSpot();
							tempTimer = 0f;
						}
						else if (Vector3.Distance(((Component)this).transform.position, hideSpot.position) < 1f)
						{
							Logger.LogDebug((object)"reached hide spot, starting sound");
							OnReachHideSpot();
						}
					}
				}
				else
				{
					PlayerControllerB val = AnyPlayerHasLineOfSight();
					if ((Object)(object)val != (Object)null)
					{
						Logger.LogDebug((object)$"playerSeeing: {val} | reachedHideSpot: {reachedHideSpot} | targetPlayer & moving: {base.targetPlayer} | {base.movingTowardsTargetPlayer}");
						base.targetPlayer = val;
						((EnemyAI)this).SwitchToBehaviourState(2);
						break;
					}
					PlayerControllerB closestPlayer = ((EnemyAI)this).GetClosestPlayer(true, false, false);
					if ((Object)(object)closestPlayer != (Object)null && Vector3.Distance(((Component)this).transform.position, ((Component)closestPlayer).transform.position) < 5f)
					{
						Logger.LogDebug((object)"distance between Enemy and ClosestPlayer below 5, moving to chase");
						base.targetPlayer = closestPlayer;
						((EnemyAI)this).SwitchToBehaviourState(2);
						break;
					}
				}
				if ((Object)(object)linkedItem != (Object)null && (Object)(object)((GrabbableObject)linkedItem).playerHeldBy != (Object)null)
				{
					base.targetPlayer = ((GrabbableObject)linkedItem).playerHeldBy;
					((EnemyAI)this).SwitchToBehaviourState(2);
				}
				if (EveryoneOutside(factorInAwarenessDistance: false))
				{
					if (tempTimer > 10f)
					{
						ResetOnEveryoneOutside();
					}
				}
				else
				{
					tempTimer = 0f;
				}
			}
			else if (!base.currentSearch.inProgress)
			{
				if (base.currentSearch.timesFinishingSearch > debugMaxSearches)
				{
					if (realAudio.isPlaying)
					{
						Logger.LogDebug((object)"out of searches, stopping");
						ToggleAudioServerRpc(enableSFX: false);
					}
				}
				else
				{
					Logger.LogDebug((object)"START search (0)");
					((EnemyAI)this).StartSearch(((Component)this).transform.position, (AISearchRoutine)null);
					base.agent.speed = roamSpeed;
					ToggleAudioServerRpc(enableSFX: true, isFootstepSFX: true, roamSpeed);
				}
			}
			else if (((EnemyAI)this).GetAllPlayersInLineOfSight(seeWidth, seeDistance, (Transform)null, -1f, -1) != null)
			{
				Logger.LogDebug((object)"enemy spotted player, moving to state 1");
				MoveToAmbush();
				if (!debugCheckSeenPosToHide)
				{
					base.agent.SetDestination(((Component)this).transform.position);
				}
			}
			break;
		case 1:
		{
			base.useSecondaryAudiosOnAnimatedObjects = false;
			if (base.currentSearch.inProgress)
			{
				((EnemyAI)this).StopSearch(base.currentSearch, true);
			}
			if (!waitingToSpawnLure)
			{
				break;
			}
			PlayerControllerB val2 = AnyPlayerHasLineOfSight();
			if ((Object)(object)val2 != (Object)null)
			{
				base.targetPlayer = val2;
				lastSeenAt = ((Component)this).transform;
				DetectNewSighting(((Component)base.targetPlayer).transform.position);
				Logger.LogInfo((object)$"enemy currently seen, set lastSeenPosition to {lastSeenAt.position}");
				if (!seenDuringThisAmbush)
				{
					seenDuringThisAmbush = true;
					PlayAnimSFX(2);
				}
			}
			if ((Object)(object)spawnLureAt == (Object)null)
			{
				if (pickLurePositionCoroutine == null)
				{
					pickLurePositionCoroutine = ((MonoBehaviour)this).StartCoroutine(PickLurePosition());
				}
				if (debugCheckSeenPosToHide)
				{
					base.agent.speed = (((Object)(object)fleeToWhileCalculating == (Object)null) ? 0f : hideSpeed);
					if ((Object)(object)fleeToWhileCalculating == (Object)null)
					{
						fleeToWhileCalculating = GetFleeToWhileCalculating(val2);
						break;
					}
					Logger.LogDebug((object)"trying to hide out of sight");
					((EnemyAI)this).SetDestinationToPosition(fleeToWhileCalculating.position, false);
				}
			}
			else
			{
				((EnemyAI)this).SetDestinationToPosition(spawnLureAt.position, true);
				if (Vector3.Distance(((Component)this).transform.position, spawnLureAt.position) < 1f)
				{
					Logger.LogDebug((object)"spawn by: DISTANCE");
					SpawnLureAndHide();
				}
				else if (debugIterationDelay <= 0f && tempTimer > maxLureSpawnTime)
				{
					Logger.LogError((object)"spawn by: TIMER");
					SpawnLureAndHide();
				}
			}
			break;
		}
		case 2:
		{
			base.useSecondaryAudiosOnAnimatedObjects = true;
			if (base.currentSearch.inProgress)
			{
				Logger.LogDebug((object)"STOP search (2)");
				((EnemyAI)this).StopSearch(base.currentSearch, true);
			}
			bool validPlayerHoldingLure = GetValidPlayerHoldingLure();
			if (EveryoneOutside(!validPlayerHoldingLure, maxDistanceBetweenFarawayNodes + 1f) && tempTimer > 5f)
			{
				ResetOnEveryoneOutside();
				break;
			}
			if (!inAttackAnimation)
			{
				if ((Object)(object)base.targetPlayer != (Object)null && (Object)(object)spawnedShovel != (Object)null && (Object)(object)spawnedShovel.transform.parent != (Object)(object)shovelParent && Vector3.Distance(((Component)this).transform.position, ((Component)base.targetPlayer).transform.position) < attackDistanceThreshold)
				{
					if (Time.realtimeSinceStartup - timeLastAttackAnimChange > attackCooldown)
					{
						PerformNextAttack();
					}
					break;
				}
				base.agent.speed = chaseSpeed;
				if ((Object)(object)base.targetPlayer == (Object)null)
				{
					if (GetValidPlayerHoldingLure())
					{
						base.targetPlayer = ((GrabbableObject)linkedItem).playerHeldBy;
					}
					else
					{
						base.targetPlayer = ((EnemyAI)this).GetClosestPlayer(false, false, false);
					}
				}
				else if (base.isOutside == base.targetPlayer.isInsideFactory || !base.targetPlayer.isPlayerControlled)
				{
					tempTimer = 0f;
					base.targetPlayer = null;
					base.movingTowardsTargetPlayer = false;
				}
				Logger.LogDebug((object)$"going to PLAYER ({base.targetPlayer})");
				ChaseNewPlayer(base.targetPlayer);
				if (!realAudio.isPlaying || (Object)(object)realAudio.clip != (Object)(object)runSFX)
				{
					ToggleAudioServerRpc(enableSFX: true, isFootstepSFX: false, chaseSpeed);
				}
			}
			if ((Object)(object)base.targetPlayer == (Object)(object)StartOfRound.Instance.localPlayerController && Vector3.Distance(((Component)this).transform.position, ((Component)base.targetPlayer).transform.position) < realAudio.maxDistance)
			{
				base.targetPlayer.JumpToFearLevel(0.8f, true);
			}
			break;
		}
		}
	}

	private IEnumerator PickLurePosition()
	{
		Logger.LogError((object)"STARTING COROUTINE PickLurePosition()!!!");
		Logger.LogInfo((object)$"allAINodes.Length = {base.allAINodes.Length}");
		Vector3 startPos = ((Component)this).transform.position;
		if (debugSpawnLights)
		{
			Object.Instantiate<GameObject>(debugNodeLightPrefab, startPos, Quaternion.identity);
		}
		List<GameObject> nodesAwayFromPlayer = new List<GameObject>();
		lastInvalidCorners.Clear();
		PlayerControllerB fromPlayer = (((Object)(object)base.targetPlayer != (Object)null) ? base.targetPlayer : ((EnemyAI)this).GetClosestPlayer(false, false, false));
		for (int j = 0; j < base.allAINodes.Length; j++)
		{
			GameObject checkingNode = base.allAINodes[j];
			Light spawnedLight = Object.Instantiate<GameObject>(debugNodeLightPrefab, checkingNode.transform.position, Quaternion.identity).GetComponent<Light>();
			if (!debugSpawnLights)
			{
				((Behaviour)spawnedLight).enabled = false;
			}
			Logger.LogDebug((object)$"checking node {checkingNode} {checkingNode.transform.position}");
			bool nodeOutOfReach = false;
			float ownDistanceToNode = Vector3.Distance(startPos, checkingNode.transform.position);
			if (ownDistanceToNode > maxSearchDistance)
			{
				nodeOutOfReach = true;
				Logger.LogDebug((object)"nodeOutOfReach: maxSearchDistance");
			}
			else if (!base.agent.CalculatePath(checkingNode.transform.position, base.path1))
			{
				nodeOutOfReach = true;
				Logger.LogDebug((object)"nodeOutOfReach: CalculatePatch()");
			}
			else if (Vector3.Distance(base.path1.corners[base.path1.corners.Length - 1], RoundManager.Instance.GetNavMeshPosition(checkingNode.transform.position, RoundManager.Instance.navHit, 2.7f, -1)) > 1.5f)
			{
				nodeOutOfReach = true;
				Logger.LogDebug((object)"nodeOutOfReach: GetNavMeshPosition()");
			}
			Logger.LogInfo((object)$"ownDistance: {ownDistanceToNode} | outOfReach: {nodeOutOfReach}");
			float closestPlayerDistanceToNode = 999f;
			if (!nodeOutOfReach)
			{
				switch (selectionMode)
				{
				case NodeSelectionMode.DistanceAllPlayers:
				{
					for (int l = 0; l < StartOfRound.Instance.allPlayerScripts.Length; l++)
					{
						PlayerControllerB val2 = StartOfRound.Instance.allPlayerScripts[l];
						if (!((Object)(object)val2 == (Object)null) && val2.isPlayerControlled && base.isOutside != val2.isInsideFactory)
						{
							Logger.LogDebug((object)$"checking player {val2}");
							float num2 = Vector3.Distance(((Component)val2).transform.position, checkingNode.transform.position);
							Logger.LogInfo((object)$"playerDistance = {num2}");
							if (num2 < closestPlayerDistanceToNode)
							{
								closestPlayerDistanceToNode = num2;
							}
						}
					}
					break;
				}
				case NodeSelectionMode.OnlyTargetPlayer:
				{
					Logger.LogDebug((object)$"checking player {fromPlayer}");
					float num3 = Vector3.Distance(((Component)fromPlayer).transform.position, checkingNode.transform.position);
					Logger.LogInfo((object)$"playerDistance = {num3}");
					if (num3 < closestPlayerDistanceToNode)
					{
						closestPlayerDistanceToNode = num3;
					}
					break;
				}
				case NodeSelectionMode.PrioritizeTargetPlayer:
				{
					for (int k = 0; k < StartOfRound.Instance.allPlayerScripts.Length; k++)
					{
						PlayerControllerB val = StartOfRound.Instance.allPlayerScripts[k];
						if (!((Object)(object)val == (Object)null) && val.isPlayerControlled && base.isOutside != val.isInsideFactory)
						{
							Logger.LogDebug((object)$"checking player {val}");
							float num = Vector3.Distance(((Component)val).transform.position, checkingNode.transform.position);
							if ((Object)(object)val != (Object)(object)fromPlayer)
							{
								num *= (float)(StartOfRound.Instance.connectedPlayersAmount + 1);
							}
							Logger.LogInfo((object)$"playerDistance = {num}");
							if (num < closestPlayerDistanceToNode)
							{
								closestPlayerDistanceToNode = num;
							}
						}
					}
					break;
				}
				}
			}
			if (debugIterationDelay > 0f)
			{
				yield return (object)new WaitForSeconds(debugIterationDelay / 2f);
			}
			Color color;
			if (ownDistanceToNode < closestPlayerDistanceToNode && !nodeOutOfReach)
			{
				Logger.LogWarning((object)$"node eligible, adding (distance: {ownDistanceToNode} VS {closestPlayerDistanceToNode})");
				nodesAwayFromPlayer.Add(checkingNode);
				color = Color.green;
			}
			else if (nodeOutOfReach)
			{
				color = Color.yellow;
			}
			else
			{
				lastInvalidCorners.Add(checkingNode.transform.position);
				color = Color.red;
			}
			spawnedLight.color = color;
			if (debugIterationDelay > 0f)
			{
				yield return (object)new WaitForSeconds(debugIterationDelay / 2f);
			}
			yield return null;
		}
		Logger.LogError((object)$"finished search of allAINodes with Count {nodesAwayFromPlayer.Count} (invalid Count: {lastInvalidCorners.Count})");
		if (nodesAwayFromPlayer.Count < minNodesAbsolute || (float)nodesAwayFromPlayer.Count < (float)base.allAINodes.Length * minNodesPercentage)
		{
			Logger.LogDebug((object)$"counted enemy having access to too little of level (<{minNodesAbsolute} = {nodesAwayFromPlayer.Count < 7} || {minNodesPercentage * 100f}% = {(float)base.allAINodes.Length * minNodesPercentage}), going straight into chase");
			((EnemyAI)this).SwitchToBehaviourState(2);
			yield break;
		}
		GameObject farthestNode = null;
		GameObject secondNode = null;
		float distanceToFarthestNode = 0f;
		Logger.LogInfo((object)$"sort node check? {!randomizeNodeCheck}");
		if (!randomizeNodeCheck)
		{
			nodesAwayFromPlayer = nodesAwayFromPlayer.OrderBy((GameObject g) => Vector3.Distance(startPos, g.transform.position)).ToList();
		}
		for (int j = 0; j < nodesAwayFromPlayer.Count; j++)
		{
			Logger.LogInfo((object)$"starting iteration [{j}]");
			GameObject val3 = nodesAwayFromPlayer[j];
			bool flag = false;
			if ((Object)(object)AnyPlayerHasLineOfSight(val3.transform.position) != (Object)null)
			{
				Logger.LogWarning((object)$"!!!Player can see node at {val3.transform.position}, skipping!!!");
				flag = true;
			}
			if (!flag)
			{
				NavMeshPath val4 = new NavMeshPath();
				base.agent.CalculatePath(val3.transform.position, val4);
				switch (hideMode)
				{
				case HideMode.InvalidNodesContains:
				{
					for (int m = 0; m < val4.corners.Length; m++)
					{
						Vector3 val5 = val4.corners[m];
						if (lastInvalidCorners.Contains(val5))
						{
							Logger.LogWarning((object)$"!!!Node at {val3.transform.position} goes across invalid node at {val5}, skipping???");
							flag = true;
							break;
						}
					}
					break;
				}
				case HideMode.PathIsIntersectedByLineOfSight:
					if (((EnemyAI)this).PathIsIntersectedByLineOfSight(val3.transform.position, false, true, true))
					{
						Logger.LogWarning((object)$"!!!Node at {val3.transform.position} intersected by line of sight, skipping???");
						flag = true;
					}
					break;
				case HideMode.LessDistanceThanTargetPlayer:
					if (TargetPlayerCloserAlongPath(val4))
					{
						Logger.LogWarning((object)$"!!!Node at {val3.transform.position} at end of path too close to targetPlayer, skipping???");
						flag = true;
					}
					break;
				}
			}
			if (flag)
			{
				continue;
			}
			Logger.LogDebug((object)$"still calculating... checking farawayNode {val3} {val3.transform.position}");
			float num4 = Vector3.Distance(startPos, val3.transform.position);
			Logger.LogDebug((object)$"distance: {num4}");
			if (num4 > distanceToFarthestNode)
			{
				if ((Object)(object)farthestNode != (Object)null)
				{
					float num5 = Vector3.Distance(val3.transform.position, farthestNode.transform.position);
					Logger.LogDebug((object)$"distanceFromPreviousFarthestNode = {num5}");
					if ((Object)(object)secondNode == (Object)null || (num5 >= minDistanceBetweenFarawayNodes && num5 <= maxDistanceBetweenFarawayNodes))
					{
						Logger.LogInfo((object)$"calculating for second node (current farthestNode) {farthestNode} {farthestNode.transform.position} || secondNode == null? {(Object)(object)secondNode == (Object)null}");
						float num6 = 0f;
						bool flag2 = false;
						switch (offsetMode)
						{
						case VerticalOffsetMode.DontCalculate:
							Logger.LogDebug((object)"VerticalOffsetMode.DontCalculate");
							break;
						case VerticalOffsetMode.RandomChance:
							if ((float)Random.Range(1, 101) < chanceToSkipOnVerticalOffset.Evaluate(num6))
							{
								Logger.LogWarning((object)"VerticalOffsetMode.RandomChance");
								flag2 = true;
							}
							break;
						case VerticalOffsetMode.IncreaseWithPower:
							num6 = Mathf.Pow(Mathf.Abs(farthestNode.transform.position.y - val3.transform.position.y), verticalOffsetDropOffPower);
							if (num6 + num5 > maxDistanceBetweenFarawayNodes)
							{
								Logger.LogWarning((object)"VerticalOffsetMode.IncreaseWithPower");
								flag2 = true;
							}
							break;
						case VerticalOffsetMode.DecreaseWithDivider:
							num6 = Mathf.Abs(farthestNode.transform.position.y - val3.transform.position.y) / verticalOffsetDropOffDivider;
							if (num6 + num5 > maxDistanceBetweenFarawayNodes)
							{
								Logger.LogWarning((object)"VerticalOffsetMode.DecreaseWithDivider");
								flag2 = true;
							}
							break;
						}
						Logger.LogDebug((object)$"verticalOffset = {num6}");
						if (!flag2 && !Physics.Linecast(val3.transform.position + Vector3.up * 1f, farthestNode.transform.position + Vector3.up * 1f, StartOfRound.Instance.collidersAndRoomMaskAndDefault, (QueryTriggerInteraction)1))
						{
							Logger.LogWarning((object)"no colliders in Linecast between farthest node and this checked second node, meaning hasLOS, skipping secondNode");
							flag2 = true;
						}
						if (!flag2 || (Object)(object)secondNode == (Object)null)
						{
							secondNode = farthestNode;
							Logger.LogDebug((object)$"picked new secondNode {secondNode.transform.position}");
						}
					}
				}
				distanceToFarthestNode = num4;
				farthestNode = val3;
				Logger.LogDebug((object)$"picked new farthest node {farthestNode.transform.position}");
			}
			if (debugIterationDelay > 0f)
			{
				yield return (object)new WaitForSeconds(debugIterationDelay);
			}
			yield return null;
		}
		if ((Object)(object)secondNode == (Object)null)
		{
			Logger.LogError((object)"failed to find spawnLurePosition, returning farthestPosition with maxSearchDistance as maxAsync");
			secondNode = ((Component)((EnemyAI)this).ChooseFarthestNodeFromPosition(startPos, true, 0, false, (int)maxSearchDistance, true)).gameObject;
		}
		spawnLureAt = secondNode.transform;
		Logger.LogError((object)$"set spawnLurePosition to (second): {spawnLureAt.position}");
		hideSpot = farthestNode.transform;
		Logger.LogWarning((object)$"hideSpot (farthest): {hideSpot.position}");
		pickLurePositionCoroutine = null;
	}

	private void StopPickLurePositionCoroutine()
	{
		if (pickLurePositionCoroutine != null)
		{
			((MonoBehaviour)this).StopCoroutine(pickLurePositionCoroutine);
			pickLurePositionCoroutine = null;
		}
	}

	private Transform GetFleeToWhileCalculating(PlayerControllerB fleeFrom = null)
	{
		//IL_001d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0033: Unknown result type (might be due to invalid IL or missing references)
		//IL_0039: Expected O, but got Unknown
		//IL_0054: 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_006d: Unknown result type (might be due to invalid IL or missing references)
		Logger.LogError((object)"Getting fleeToWhileCalculating!!!");
		Transform val = ((Component)this).transform;
		Transform val2 = ((EnemyAI)this).ChooseFarthestNodeFromPosition(((Component)this).transform.position, false, 0, false, (int)maxSearchDistance, true);
		NavMeshPath val3 = new NavMeshPath();
		if ((Object)(object)fleeFrom == (Object)null)
		{
			fleeFrom = ((EnemyAI)this).GetClosestPlayer(false, false, false);
		}
		if (base.agent.CalculatePath(val2.position, val3))
		{
			if (TargetPlayerCloserAlongPath(val3, fleeFrom))
			{
				val2 = ((EnemyAI)this).ChooseFarthestNodeFromPosition(val2.position, false, 0, false, (int)maxSearchDistance * 2, true);
				Logger.LogDebug((object)$"getting new farthestNode {val2}");
			}
			else
			{
				Logger.LogInfo((object)$"managed to finish first path to farthestNode {val2}");
			}
			val = val2;
		}
		else
		{
			Logger.LogError((object)"failed to get toReturn!");
		}
		Logger.LogInfo((object)$"sending toReturn {val} fleeToWhileCalculating {val.position}");
		return val;
	}

	private bool TargetPlayerCloserAlongPath(NavMeshPath path, PlayerControllerB fleeFrom = null)
	{
		//IL_0037: Unknown result type (might be due to invalid IL or missing references)
		//IL_003c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0043: Unknown result type (might be due to invalid IL or missing references)
		//IL_0048: Unknown result type (might be due to invalid IL or missing references)
		//IL_0055: Unknown result type (might be due to invalid IL or missing references)
		//IL_005a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0084: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)fleeFrom == (Object)null)
		{
			fleeFrom = ((!((Object)(object)base.targetPlayer != (Object)null)) ? ((EnemyAI)this).GetClosestPlayer(false, false, false) : base.targetPlayer);
		}
		for (int i = 0; i < path.corners.Length; i++)
		{
			Vector3 val = path.corners[i];
			float num = Vector3.Distance(((Component)this).transform.position, val);
			float num2 = Vector3.Distance(((Component)fleeFrom).transform.position, val);
			if (num > num2 && num2 < maxPlayerDistanceToHidePath)
			{
				Logger.LogWarning((object)$"player {num2} closer than I {num} to corner {val}");
				return true;
			}
		}
		return false;
	}

	private bool EveryoneOutside(bool factorInAwarenessDistance = true, float overrideAwarenessDistance = -1f)
	{
		//IL_0045: Unknown result type (might be due to invalid IL or missing references)
		//IL_0050: Unknown result type (might be due to invalid IL or missing references)
		if (overrideAwarenessDistance == -1f)
		{
			overrideAwarenessDistance = awarenessDistance;
		}
		PlayerControllerB[] allPlayerScripts = StartOfRound.Instance.allPlayerScripts;
		foreach (PlayerControllerB val in allPlayerScripts)
		{
			if (val.isPlayerControlled && base.isOutside == !val.isInsideFactory && (!factorInAwarenessDistance || Vector3.Distance(((Component)this).transform.position, ((Component)val).transform.position) < overrideAwarenessDistance))
			{
				everyoneOutside = false;
				return everyoneOutside;
			}
		}
		everyoneOutside = true;
		return everyoneOutside;
	}

	private PlayerControllerB AnyPlayerHasLineOfSight(Vector3 pos = default(Vector3))
	{
		//IL_0000: Unknown result type (might be due to invalid IL or missing references)
		//IL_0003: Unknown result type (might be due to invalid IL or missing references)
		//IL_0009: Unknown result type (might be due to invalid IL or missing references)
		//IL_0017: Unknown result type (might be due to invalid IL or missing references)
		//IL_001c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0041: Unknown result type (might be due to invalid IL or missing references)
		if (pos == default(Vector3))
		{
			pos = base.eye.position;
		}
		for (int i = 0; i < StartOfRound.Instance.allPlayerScripts.Length; i++)
		{
			PlayerControllerB val = StartOfRound.Instance.allPlayerScripts[i];
			if ((Object)(object)val != (Object)null && val.isPlayerControlled && val.HasLineOfSightToPosition(pos, 50f, 40, -1f))
			{
				return val;
			}
		}
		return null;
	}

	public static void DestroyAllNodeLights()
	{
		Light[] array = Object.FindObjectsByType<Light>((FindObjectsSortMode)0);
		int num = 0;
		for (int num2 = array.Length - 1; num2 >= 0; num2--)
		{
			GameObject gameObject = ((Component)array[num2]).gameObject;
			if (((Object)gameObject).name == "EnemyNodeLight(Clone)")
			{
				Object.Destroy((Object)(object)gameObject);
				num++;
			}
		}
		Logger.LogInfo((object)$"DestroyAllNodeLights finished with lightsDestroyed {num}");
	}

	private void ResetOnEveryoneOutside(bool unlinkItem = true, bool despawnNetObj = false, bool resetAmbush = false)
	{
		if (!((NetworkBehaviour)this).IsServer)
		{
			Logger.LogWarning((object)"non-server owner trying to reset, relinquishing control back to player #0 in hopes they notice no one is outside during chase, to reset properly");
			((EnemyAI)this).ChangeOwnershipOfEnemy(StartOfRound.Instance.allPlayerScripts[0].actualClientId);
			return;
		}
		Logger.LogWarning((object)"RESET!!!");
		if ((Object)(object)linkedItem != (Object)null)
		{
			NetworkObject networkObject = ((NetworkBehaviour)linkedItem).NetworkObject;
			if (unlinkItem)
			{
				Logger.LogDebug((object)$"unlinking {linkedItem}");
				linkedItem.ToggleAudioFromEnemy(enabled: false);
				linkedItem = null;
			}
			if (despawnNetObj && (Object)(object)networkObject != (Object)null)
			{
				Logger.LogInfo((object)$"despawning {networkObject}");
				networkObject.Despawn(true);
			}
		}
		if (resetAmbush)
		{
			Logger.LogDebug((object)"resetting ambush");
			performedAmushAttack = false;
			SwitchToAttackSequence(0);
		}
		setLureLocally = false;
		reachedHideSpot = false;
		base.targetPlayer = null;
		base.movingTowardsTargetPlayer = false;
		hideSpot = null;
		spawnLureAt = null;
		waitingToSpawnLure = false;
		tempTimer = 0f;
		lastSeenAt = null;
		fleeToWhileCalculating = null;
		pickLurePositionCoroutine = null;
		seenDuringThisAmbush = false;
		base.currentSearch.timesFinishingSearch = 0;
		currentAttackIndex = -1;
		Logger.LogInfo((object)"set everything back");
		DestroyAllNodeLights();
		if (base.currentBehaviourStateIndex != 0)
		{
			Logger.LogDebug((object)"exiting chase");
			((EnemyAI)this).SwitchToBehaviourState(0);
		}
		Logger.LogInfo((object)"Successfully reached end of ResetOnEveryoneOutside()");
	}

	private void OnReachHideSpot()
	{
		reachedHideSpot = true;
		base.movingTowardsTargetPlayer = false;
		tempTimer = 0f;
		if ((Object)(object)linkedItem != (Object)null)
		{
			linkedItem.ToggleAudioFromEnemy(enabled: true);
		}
		else
		{
			ToggleAudioServerRpc(enableSFX: true);
		}
	}

	private void SpawnLureAndHide()
	{
		//IL_0075: Unknown result type (might be due to invalid IL or missing references)
		setLureLocally = true;
		int num = Random.Range(1, 101);
		Logger.LogDebug((object)num);
		if (!performedAmushAttack || num <= chanceToPlayFakeAudio)
		{
			SpawnLureItemServerRpc();
		}
		waitingToSpawnLure = false;
		reachedHideSpot = false;
		tempTimer = 0f;
		if ((Object)(object)hideSpot == (Object)null)
		{
			Logger.LogInfo((object)"ChooseFarthestNodeFromPosition()!!");
			hideSpot = ((EnemyAI)this).ChooseFarthestNodeFromPosition(spawnLureAt.position, true, 0, true, (int)maxDistanceBetweenFarawayNodes, true);
		}
		Logger.LogDebug((object)"spawned lure, going back to state 0");
		((EnemyAI)this).SwitchToBehaviourState(0);
	}

	private void MoveToAmbush()
	{
		if (base.currentBehaviourStateIndex == 0 && !setLureLocally)
		{
			base.agent.speed = 0f;
			waitingToSpawnLure = true;
			spawnLureAt = null;
			tempTimer = 0f;
			if (base.currentSearch.inProgress)
			{
				((EnemyAI)this).StopSearch(base.currentSearch, true);
			}
			((EnemyAI)this).SwitchToBehaviourState(1);
			ToggleAudioServerRpc(enableSFX: false, isFootstepSFX: true, hideSpeed);
		}
	}

	private void DetectNewSighting(Vector3 lookPos, bool lookImmediately = false)
	{
		//IL_005c: Unknown result type (might be due to invalid IL or missing references)
		//IL_005d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0009: Unknown result type (might be due to invalid IL or missing references)
		//IL_001b: Unknown result type (might be due to invalid IL or missing references)
		//IL_002b: Unknown result type (might be due to invalid IL or missing references)
		//IL_003b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0045: Unknown result type (might be due to invalid IL or missing references)
		if (lookImmediately)
		{
			turnCompass.LookAt(lookPos);
			((Component)this).transform.eulerAngles = new Vector3(((Component)this).transform.eulerAngles.x, turnCompass.eulerAngles.y, ((Component)this).transform.eulerAngles.z);
		}
		else
		{
			lookingTime = Time.realtimeSinceStartup;
			lookingAt = lookPos;
		}
	}

	public void SetEnemyVulnerable(bool setVulnerableTo)
	{
		vulnerable = setVulnerableTo;
		Logger.LogDebug((object)$"vulnerable: {vulnerable}");
	}

	public void SetEnemyInAttackAnimation(bool setInAttackAnimTo)
	{
		inAttackAnimation = setInAttackAnimTo;
		Logger.LogDebug((object)$"inAttackAnimation: {inAttackAnimation}");
		timeLastAttackAnimChange = Time.realtimeSinceStartup;
	}

	private bool GetValidPlayerHoldingLure()
	{
		if ((Object)(object)linkedItem == (Object)null)
		{
			return false;
		}
		if ((Object)(object)((GrabbableObject)linkedItem).playerHeldBy == (Object)null)
		{
			return false;
		}
		if (base.isOutside == ((GrabbableObject)linkedItem).playerHeldBy.isInsideFactory)
		{
			return false;
		}
		if (!((GrabbableObject)linkedItem).playerHeldBy.isPlayerControlled)
		{
			return false;
		}
		return true;
	}

	private void LinkEnemyToLure()
	{
		if ((Object)(object)linkedItem != (Object)null)
		{
			Logger.LogDebug((object)$"{((Object)this).name} #{((NetworkBehaviour)this).NetworkObjectId} already linked to {((Object)linkedItem).name} #{((NetworkBehaviour)linkedItem).NetworkObjectId}");
		}
		else
		{
			EnemyLureTestItem enemyLureTestItem = Object.FindAnyObjectByType<EnemyLureTestItem>();
			if ((Object)(object)enemyLureTestItem != (Object)null)
			{
				enemyLureTestItem.LinkLureToEnemy(this);
			}
		}
	}

	private void TurnPlayerTo(PlayerControllerB player, Vector3 turnTo = default(Vector3))
	{
		//IL_0000: Unknown result type (might be due to invalid IL or missing references)
		//IL_0003: Unknown result type (might be due to invalid IL or missing references)
		//IL_0009: Unknown result type (might be due to invalid IL or missing references)
		//IL_002e: 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_005e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0075: Unknown result type (might be due to invalid IL or missing references)
		//IL_0084: Unknown result type (might be due to invalid IL or missing references)
		//IL_0017: Unknown result type (might be due to invalid IL or missing references)
		//IL_001c: Unknown result type (might be due to invalid IL or missing references)
		if (turnTo == default(Vector3))
		{
			turnTo = ((Component)this).transform.position;
		}
		RoundManager.Instance.tempTransform.position = ((Component)player).transform.position;
		RoundManager.Instance.tempTransform.LookAt(turnTo);
		Quaternion rotation = RoundManager.Instance.tempTransform.rotation;
		((Component)player).transform.rotation = rotation;
		((Component)player).transform.eulerAngles = new Vector3(0f, ((Component)player).transform.eulerAngles.y, 0f);
	}

	private IEnumerator PerformPlayerCollision(PlayerControllerB collidedPlayer)
	{
		if ((Object)(object)spawnedShovel != (Object)null && (Object)(object)spawnedShovel.transform.parent != (Object)(object)shovelParent)
		{
			Logger.LogDebug((object)("shovel not on " + ((Object)shovelParent).name + " anymore, likely already given to player, breaking"));
		}
		else if (base.currentBehaviourStateIndex == 2)
		{
			Logger.LogDebug((object)$"inAttackAnimation? {inAttackAnimation} | debugInstantKillOnChase? {debugInstantKillOnChase}");
			if (debugInstantKillOnChase)
			{
				collidedPlayer.KillPlayer(base.eye.forward * 3f, true, (CauseOfDeath)6, 8, default(Vector3));
			}
			else
			{
				if (inAttackAnimation)
				{
					yield break;
				}
				Logger.LogInfo((object)"starting kill animation!!");
				base.agent.speed = 0f;
				SetEnemyInAttackAnimation(setInAttackAnimTo: true);
				ToggleAudioServerRpc(enableSFX: false);
				base.inSpecialAnimationWithPlayer = collidedPlayer;
				collidedPlayer.inAnimationWithEnemy = (EnemyAI)(object)this;
				collidedPlayer.inSpecialInteractAnimation = true;
				RoundManager.Instance.tempTransform.position = ((Component)collidedPlayer).transform.position;
				RoundManager.Instance.tempTransform.LookAt(((Component)this).transform.position);
				Quaternion startingPlayerRot = ((Component)collidedPlayer).transform.rotation;
				Quaternion targetPlayerRot = RoundManager.Instance.tempTransform.rotation;
				for (int i = 0; i < debugTurnPlayerIterations; i++)
				{
					((Component)collidedPlayer).transform.rotation = Quaternion.Lerp(startingPlayerRot, targetPlayerRot, (float)i / (float)debugTurnPlayerIterations);
					((Component)collidedPlayer).transform.eulerAngles = new Vector3(0f, ((Component)collidedPlayer).transform.eulerAngles.y, 0f);
					yield return null;
				}
				DetectNewSighting(((Component)collidedPlayer).transform.position, lookImmediately: true);
				yield return (object)new WaitForSeconds(0.1f);
				if (performedAmushAttack)
				{
					collidedPlayer.DropAllHeldItemsAndSync();
					SetAnimation("GiveShovel");
					yield return (object)new WaitForSeconds(0.75f);
					GiveShovelLocal(collidedPlayer);
					GiveShovelToPlayerServerRpc((int)collidedPlayer.playerClientId);
					if ((Object)(object)linkedItem != (Object)null && linkedItem.fakeAudio.isPlaying)
					{
						linkedItem.ToggleAudioFromEnemy(enabled: false);
					}
					collidedPlayer.inSpecialInteractAnimation = false;
					collidedPlayer.inAnimationWithEnemy = null;
					base.inSpecialAnimationWithPlayer = null;
					yield return null;
					collidedPlayer.externalForceAutoFade = ((Component)this).transform.forward * 20f + Vector3.up * 20f;
					PlayAnimSFX(3);
					yield return (object)new WaitForSeconds(1f);
					SetEnemyInAttackAnimation(setInAttackAnimTo: false);
				}
				else
				{
					collidedPlayer.inSpecialInteractAnimation = false;
					collidedPlayer.inAnimationWithEnemy = null;
					base.inSpecialAnimationWithPlayer = null;
					yield return null;
					collidedPlayer.externalForceAutoFade = ((Component)this).transform.forward * 5f + Vector3.up * 5f;
					yield return (object)new WaitForSeconds(0.33f);
					PerformNextAttack();
				}
			}
		}
		else
		{
			collidedPlayer.DamagePlayer(10, true, true, (CauseOfDeath)12, 0, false, base.eye.forward * 10f + Vector3.up * 3f);
		}
	}

	private void PerformNextAttack()
	{
		//IL_0019: Unknown result type (might be due to invalid IL or missing references)
		ToggleAudioServerRpc(enableSFX: false);
		DetectNewSighting(((Component)base.targetPlayer).transform.position, lookImmediately: true);
		base.agent.speed = 0f;
		SetEnemyInAttackAnimation(setInAttackAnimTo: true);
		GetNextAttackIndex();
		currentAttackTrigger = currentAttackSequence.attackAnimSequence[currentAttackIndex].ToString();
		currentAttackState = "WindUp";
		SetAnimation(currentAttackTrigger + currentAttackState, currentAttackIndex);
	}

	private void GetNextAttackIndex()
	{
		currentAttackIndex++;
		if (currentAttackIndex >= currentAttackSequence.attackAnimSequence.Length)
		{
			currentAttackIndex = 0;
		}
		Logger.LogDebug((object)$"index: {currentAttackIndex} | trigger: {currentAttackSequence.attackAnimSequence[currentAttackIndex].ToString()}");
	}

	private void SwitchToAttackSequence(int index)
	{
		currentAttackSequence = testAttackAnimSequences[index];
		currentAttackIndex = -1;
		Logger.LogInfo((object)$"!!!SWITCHING TO NEW ATTACK PATTERN: [{index}] '{((Object)currentAttackSequence).name}'");
	}

	public override void FinishedCurrentSearchRoutine()
	{
		//IL_0060: Unknown result type (might be due to invalid IL or missing references)
		//IL_0065: Unknown result type (might be due to invalid IL or missing references)
		//IL_0071: Unknown result type (might be due to invalid IL or missing references)
		((EnemyAI)this).FinishedCurrentSearchRoutine();
		Logger.LogDebug((object)$"FINISHED SEARCH; times {base.currentSearch.timesFinishingSearch}");
		if (base.currentSearch.timesFinishingSearch > debugMaxSearches)
		{
			Logger.LogDebug((object)"NO MORE SEARCHES LEFT");
			((EnemyAI)this).StopSearch(base.currentSearch, true);
			base.destination = ((Component)this).transform.position;
			base.agent.SetDestination(base.destination);
		}
	}

	public override void SetEnemyStunned(bool setToStunned, float setToStunTime = 1f, PlayerControllerB setStunnedByPlayer = null)
	{
		((EnemyAI)this).SetEnemyStunned(setToStunned, setToStunTime, setStunnedByPlayer);
		Logger.LogDebug((object)$"stunning {((Object)this).name} #{((NetworkBehaviour)this).NetworkObjectId} [{base.thisEnemyIndex}]");
	}

	public override void HitEnemy(int force = 1, PlayerControllerB playerWhoHit = null, bool playHitSFX = false, int hitID = -1)
	{
		((EnemyAI)this).HitEnemy(force, playerWhoHit, playHitSFX, hitID);
		if (base.isEnemyDead)
		{
			return;
		}
		Logger.LogDebug((object)$"hitEnemy | vulnerable: {vulnerable}");
		if (vulnerable)
		{
			base.creatureSFX.PlayOneShot(intimidateSFX);
			base.enemyHP -= force;
			Logger.LogDebug((object)$"HP: {base.enemyHP}");
			if (base.enemyHP == 3)
			{
				((Renderer)changeMatOf).material = changeMatTo;
				SwitchToAttackSequence(1);
				base.creatureSFX.PlayOneShot(bellSFX);
				currentAttackIndex = -1;
			}
			if (base.enemyHP <= 0)
			{
				((EnemyAI)this).KillEnemyOnOwnerClient(false);
			}
		}
		else
		{
			base.creatureSFX.PlayOneShot(blockSFX);
		}
	}

	public override void KillEnemy(bool destroy = false)
	{
		//IL_000d: Unknown result type (might be due to invalid IL or missing references)
		((EnemyAI)this).KillEnemy(destroy);
		Landmine.SpawnExplosion(((Component)this).transform.position, true, 0f, 0f, 0, 0f, (GameObject)null, false);
		((EnemyAI)this).EnableEnemyMesh(false, false);
		StopPickLurePositionCoroutine();
		realAudio.Stop();
		SetEnemyInAttackAnimation(setInAttackAnimTo: false);
	}

	public override void ReachedNodeInSearch()
	{
		((EnemyAI)this).ReachedNodeInSearch();
		Logger.LogDebug((object)$"{((Object)this).name} #{((NetworkBehaviour)this).NetworkObjectId} reached node");
	}

	public override void OnCollideWithPlayer(Collider other)
	{
		if (!base.isEnemyDead && !inAttackAnimation && Time.realtimeSinceStartup - timeLastCollisionLocalPlayer > collisionCooldown)
		{
			PlayerControllerB val = ((EnemyAI)this).MeetsStandardPlayerCollisionConditions(other, false, false);
			if ((Object)(object)val != (Object)null && (Object)(object)val == (Object)(object)base.targetPlayer && val.thisController.isGrounded)
			{
				((EnemyAI)this).OnCollideWithPlayer(other);
				timeLastCollisionLocalPlayer = Time.realtimeSinceStartup;
				((MonoBehaviour)this).StartCoroutine(PerformPlayerCollision(val));
			}
		}
	}

	public override void OnCollideWithEnemy(Collider other, EnemyAI collidedEnemy = null)
	{
		if (!base.isEnemyDead)
		{
			((EnemyAI)this).OnCollideWithEnemy(other, collidedEnemy);
			if ((Object)(object)collidedEnemy != (Object)null && !collidedEnemy.isEnemyDead && collidedEnemy.enemyType.canDie)
			{
				Logger.LogDebug((object)$"demolishing {((Object)collidedEnemy).name} #{collidedEnemy.thisEnemyIndex}");
				collidedEnemy.KillEnemyOnOwnerClient(false);
			}
		}
	}

	public override void DetectNoise(Vector3 noisePosition, float noiseLoudness, int timesPlayedInOneSpot = 0, int noiseID = 0)
	{
		//IL_0001: Unknown result type (might be due to invalid IL or missing references)
		//IL_0035: Unknown result type (might be due to invalid IL or missing references)
		//IL_003a: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
		((EnemyAI)this).DetectNoise(noisePosition, noiseLoudness, timesPlayedInOneSpot, noiseID);
		if (OnDetectNoiseValid())
		{
			if (noiseID == 6 || noiseID == 7)
			{
				noiseLoudness = 0.6f;
			}
			float num = Mathf.Max(1f, 80f - Mathf.Pow(Vector3.Distance(((Component)this).transform.position, noisePosition), noiseDistanceDropoffPower));
			float num2 = noiseLoudness * 100f;
			float num3 = num + num2;
			Logger.LogDebug((object)$"(ID: {noiseID}) // {num} + {num2} = {num3}");
			if (num3 >= noiseThreshold * noiseLookThreshold)
			{
				DetectNewSighting(noisePosition);
			}
			if (num3 >= noiseThreshold)
			{
				Logger.LogDebug((object)"passed threshold, moving to state 1");
				MoveToAmbush();
			}
		}
	}

	private bool OnDetectNoiseValid()
	{
		if (!((NetworkBehaviour)this).IsOwner)
		{
			Logger.LogDebug((object)"DetectNoise(): not owner");
			return false;
		}
		if (base.isEnemyDead)
		{
			Logger.LogDebug((object)"DetectNoise(): dead");
			return false;
		}
		if (!statesDetectingNoise.Contains(base.currentBehaviourStateIndex))
		{
			Logger.LogDebug((object)"DetectNoise(): not state detecting noise");
			return false;
		}
		if (EveryoneOutside())
		{
			Logger.LogDebug((object)"DetectNoise(): everyone outside awarness radius");
			return false;
		}
		return true;
	}

	[ServerRpc(RequireOwnership = false)]
	private void SpawnLureItemServerRpc()
	{
		//IL_0024: Unknown result type (might be due to invalid IL or missing references)
		//IL_002e: Invalid comparison between Unknown and I4
		//IL_008c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0096: Invalid comparison between Unknown and I4
		//IL_005f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0068: Unknown result type (might be due to invalid IL or missing references)
		//IL_006d: Unknown result type (might be due to invalid IL or missing references)
		//IL_007c: Unknown result type (might be due to invalid IL or missing references)
		//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
		//IL_00db: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
		NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
		if (networkManager != null && networkManager.IsListening)
		{
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				ServerRpcParams val = default(ServerRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(1280540858u, val, (RpcDelivery)0);
				((NetworkBehaviour)this).__endSendServerRpc(ref val2, 1280540858u, val, (RpcDelivery)0);
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				Object.Instantiate<GameObject>(itemToSpawn.spawnPrefab, ((Component)this).transform.position + Vector3.up * 2f, Quaternion.identity, RoundManager.Instance.spawnedScrapContainer).GetComponent<NetworkObject>().Spawn(false);
			}
		}
	}

	private void SpawnShovelAndSync()
	{
		//IL_0016: Unknown result type (might be due to invalid IL or missing references)
		//IL_001b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0081: Unknown result type (might be due to invalid IL or missing references)
		spawnedShovel = Object.Instantiate<GameObject>(shovelItem.spawnPrefab, ((Component)shovelParent).transform.position, Quaternion.identity, shovelParent);
		Shovel component = spawnedShovel.GetComponent<Shovel>();
		((GrabbableObject)component).hasHitGround = true;
		((GrabbableObject)component).reachedFloorTarget = true;
		((GrabbableObject)component).isInFactory = true;
		((GrabbableObject)component).grabbable = false;
		((GrabbableObject)component).parentObject = shovelParent;
		NetworkObject networkObject = ((NetworkBehaviour)component).NetworkObject;
		networkObject.Spawn(false);
		Logger.LogDebug((object)"spawned shovel on host");
		SpawnShovelClientRpc(NetworkObjectReference.op_Implicit(networkObject));
	}

	[ClientRpc]
	private void SpawnShovelClientRpc(NetworkObjectReference itemNOR)
	{
		//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_00e0: 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 != 2 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val = default(ClientRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(4112359130u, val, (RpcDelivery)0);
				((FastBufferWriter)(ref val2)).WriteValueSafe<NetworkObjectReference>(ref itemNOR, default(ForNetworkSerializable));
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 4112359130u, val, (RpcDelivery)0);
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 2 && (networkManager.IsClient || networkManager.IsHost) && !((NetworkBehaviour)this).IsServer)
			{
				((MonoBehaviour)this).StartCoroutine(WaitForShovelToSpawnOnClient(itemNOR));
			}
		}
	}

	private IEnumerator WaitForShovelToSpawnOnClient(NetworkObjectReference itemNOR)
	{
		//IL_000e: Unknown result type (might be due to invalid IL or missing references)
		//IL_000f: Unknown result type (might be due to invalid IL or missing references)
		NetworkObject netObj = null;
		float startTime = Time.realtimeSinceStartup;
		while (Time.realtimeSinceStartup - startTime < 8f && !((NetworkObjectReference)(ref itemNOR)).TryGet(ref netObj, (NetworkManager)null))
		{
			yield return (object)new WaitForSeconds(0.03f);
		}
		if ((Object)(object)netObj == (Object)null)
		{
			Logger.LogError((object)"failed to get Shovel netObj on client!");
			yield break;
		}
		yield return (object)new WaitForEndOfFrame();
		spawnedShovel = ((Component)netObj).gameObject;
		((Component)netObj).transform.SetParent(shovelParent);
		Shovel component = ((Component)netObj).GetComponent<Shovel>();
		((GrabbableObject)component).hasHitGround = true;
		((GrabbableObject)component).reachedFloorTarget = true;
		((GrabbableObject)component).isInFactory = true;
		((GrabbableObject)component).grabbable = false;
		((GrabbableObject)component).parentObject = shovelParent;
		Logger.LogDebug((object)"spawned shovel on client");
	}

	[ServerRpc(RequireOwnership = false)]
	private void GiveShovelToPlayerServerRpc(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)
		NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
		if (networkManager != null && networkManager.IsListening)
		{
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				ServerRpcParams val = default(ServerRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(903098992u, val, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val2, playerID);
				((NetworkBehaviour)this).__endSendServerRpc(ref val2, 903098992u, val, (RpcDelivery)0);
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				GiveShovelToPlayerClientRpc(playerID);
			}
		}
	}

	[ClientRpc]
	private void GiveShovelToPlayerClientRpc(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)
		NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
		if (networkManager != null && networkManager.IsListening)
		{
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 2 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val = default(ClientRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(1207083148u, val, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val2, playerID);
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 1207083148u, val, (RpcDelivery)0);
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 2 && (networkManager.IsClient || networkManager.IsHost) && playerID != (int)GameNetworkManager.Instance.localPlayerController.playerClientId)
			{
				GiveShovelLocal(StartOfRound.Instance.allPlayerScripts[playerID]);
			}
		}
	}

	private void GiveShovelLocal(PlayerControllerB giveToPlayer)
	{
		//IL_0188: Unknown result type (might be due to invalid IL or missing references)
		Logger.LogWarning((object)$"GIVING SHOVEL TO {giveToPlayer}!!!");
		Shovel component = spawnedShovel.GetComponent<Shovel>();
		giveToPlayer.ItemSlots[giveToPlayer.currentItemSlot] = (GrabbableObject)(object)component;
		giveToPlayer.playerBodyAnimator.SetBool(shovelItem.grabAnim, true);
		giveToPlayer.playerBodyAnimator.SetBool("GrabValidated", true);
		giveToPlayer.playerBodyAnimator.SetBool("cancelHolding", false);
		giveToPlayer.playerBodyAnimator.ResetTrigger("SwitchHoldAnimationTwoHanded");
		giveToPlayer.playerBodyAnimator.SetTrigger("SwitchHoldAnimationTwoHanded");
		giveToPlayer.itemAudio.PlayOneShot(shovelItem.grabSFX);
		giveToPlayer.currentlyHeldObject = (GrabbableObject)(object)component;
		giveToPlayer.currentlyHeldObjectServer = (GrabbableObject)(object)component;
		giveToPlayer.twoHanded = shovelItem.twoHanded;
		giveToPlayer.twoHandedAnimation = shovelItem.twoHandedAnimation;
		giveToPlayer.isHoldingObject = true;
		giveToPlayer.carryWeight = Mathf.Clamp(giveToPlayer.carryWeight + (shovelItem.weight - 1f), 1f, 10f);
		if ((Object)(object)giveToPlayer == (Object)(object)GameNetworkManager.Instance.localPlayerController)
		{
			HUDManager.Instance.itemSlotIcons[giveToPlayer.currentItemSlot].sprite = shovelItem.itemIcon;
			((Behaviour)HUDManager.Instance.itemSlotIcons[giveToPlayer.currentItemSlot]).enabled = true;
		}
		((GrabbableObject)component).parentObject = (((Object)(object)giveToPlayer == (Object)(object)GameNetworkManager.Instance.localPlayerController) ? giveToPlayer.localItemHolder : giveToPlayer.serverItemHolder);
		((GrabbableObject)component).isHeld = true;
		((GrabbableObject)component).playerHeldBy = giveToPlayer;
		((GrabbableObject)component).grabbable = true;
		((Component)component).transform.localScale = ((GrabbableObject)component).originalScale;
		((GrabbableObject)component).EnableItemMeshes(true);
		((GrabbableObject)component).EnablePhysics(false);
		((GrabbableObject)component).GrabItemOnClient();
		((GrabbableObject)component).EquipItem();
		if (((NetworkBehaviour)this).IsServer)
		{
			try
			{
				((NetworkBehaviour)component).NetworkObject.ChangeOwnership(giveToPlayer.actualClientId);
			}
			catch
			{
				Logger.LogError((object)"failed to ChangeOwnership to new player!");
			}
		}
		spawnedShovel.transform.SetParent(((GrabbableObject)component).parentObject, true);
		Logger.LogDebug((object)"reached end of GiveShovelLocal()");
	}

	public void ChaseNewPlayer(PlayerControllerB player)
	{
		if (!((Object)(object)player == (Object)null) && ((NetworkBehaviour)this).IsOwner && !base.movingTowardsTargetPlayer)
		{
			Logger.LogWarning((object)("started new chase on owner, should sync AI-Calculation to chased player " + ((Object)player).name));
			((EnemyAI)this).ChangeOwnershipOfEnemy(player.actualClientId);
			ChasePlayerServerRpc((int)player.playerClientId);
		}
	}

	[ServerRpc(RequireOwnership = false)]
	private void ChasePlayerServerRpc(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)
		NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
		if (networkManager != null && networkManager.IsListening)
		{
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				ServerRpcParams val = default(ServerRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(1404863536u, val, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val2, playerID);
				((NetworkBehaviour)this).__endSendServerRpc(ref val2, 1404863536u, val, (RpcDelivery)0);
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ChasePlayerClientRpc(playerID);
			}
		}
	}

	[ClientRpc]
	private void ChasePlayerClientRpc(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)
		NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
		if (networkManager != null && networkManager.IsListening)
		{
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 2 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val = default(ClientRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(3380684369u, val, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val2, playerID);
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 3380684369u, val, (RpcDelivery)0);
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 2 && (networkManager.IsClient || networkManager.IsHost))
			{
				ChaseNewPlayerOnLocalClient(StartOfRound.Instance.allPlayerScripts[playerID]);
			}
		}
	}

	private void ChaseNewPlayerOnLocalClient(PlayerControllerB playerToChase)
	{
		base.agent.speed = chaseSpeed;
		((EnemyAI)this).SetMovingTowardsTargetPlayer(playerToChase);
	}

	[ServerRpc(RequireOwnership = false)]
	private void ToggleAudioServerRpc(bool enableSFX, bool isFootstepSFX = true, float agentSpeed = -1f)
	{
		//IL_0024: Unknown result type (might be due to invalid IL or missing references)
		//IL_002e: Invalid comparison between Unknown and I4
		//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e7: Invalid comparison between Unknown and I4
		//IL_005f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0068: Unknown result type (might be due to invalid IL or missing references)
		//IL_006d: Unknown result type (might be due to invalid IL or missing references)
		//IL_007d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0083: Unknown result type (might be due to invalid IL or missing references)
		//IL_0098: Unknown result type (might be due to invalid IL or missing references)
		//IL_009e: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
		//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
		NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
		if (networkManager != null && networkManager.IsListening)
		{
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				ServerRpcParams val = default(ServerRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(2785788926u, val, (RpcDelivery)0);
				((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref enableSFX, default(ForPrimitives));
				((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref isFootstepSFX, default(ForPrimitives));
				((FastBufferWriter)(ref val2)).WriteValueSafe<float>(ref agentSpeed, default(ForPrimitives));
				((NetworkBehaviour)this).__endSendServerRpc(ref val2, 2785788926u, val, (RpcDelivery)0);
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ToggleAudioClientRpc(enableSFX, isFootstepSFX, agentSpeed);
			}
		}
	}

	[ClientRpc]
	private void ToggleAudioClientRpc(bool enableSFX, bool isFootstepSFX = true, float agentSpeed = -1f)
	{
		//IL_0024: Unknown result type (might be due to invalid IL or missing references)
		//IL_002e: Invalid comparison between Unknown and I4
		//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e7: Invalid comparison between Unknown and I4
		//IL_005f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0068: Unknown result type (might be due to invalid IL or missing references)
		//IL_006d: Unknown result type (might be due to invalid IL or missing references)
		//IL_007d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0083: Unknown result type (might be due to invalid IL or missing references)
		//IL_0098: Unknown result type (might be due to invalid IL or missing references)
		//IL_009e: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
		//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
		NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
		if (networkManager == null || !networkManager.IsListening)
		{
			return;
		}
		if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 2 && (networkManager.IsServer || networkManager.IsHost))
		{
			ClientRpcParams val = default(ClientRpcParams);
			FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(4019043694u, val, (RpcDelivery)0);
			((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref enableSFX, default(ForPrimitives));
			((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref isFootstepSFX, default(ForPrimitives));
			((FastBufferWriter)(ref val2)).WriteValueSafe<float>(ref agentSpeed, default(ForPrimitives));
			((NetworkBehaviour)this).__endSendClientRpc(ref val2, 4019043694u, val, (RpcDelivery)0);
		}
		if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 2 && (networkManager.IsClient || networkManager.IsHost))
		{
			if (agentSpeed == -1f)
			{
				agentSpeed = base.agent.speed;
			}
			base.agent.speed = agentSpeed;
			ToggleRealAudio(enableSFX, isFootstepSFX);
		}
	}

	private void ToggleRealAudio(bool enableSFX, bool isFootstepSFX)
	{
		if (!enableSFX || realAudio.isPlaying)
		{
			realAudio.Stop();
		}
		if (enableSFX)
		{
			realAudio.clip = (isFootstepSFX ? footstepSFX : runSFX);
			realAudio.Play();
		}
	}

	public void PlayAnimSFX(int switchCase, bool sync = true, int sentPlayerID = -1)
	{
		switch (switchCase)
		{
		case 0:
			base.creatureSFX.PlayOneShot(reelSFX);
			break;
		case 1:
			base.creatureSFX.PlayOneShot(punchSFX);
			break;
		case 2:
			base.creatureSFX.PlayOneShot(intimidateSFX);
			break;
		case 3:
			base.creatureSFX.PlayOneShot(bellSFX);
			break;
		case 4:
			if (!performedAmushAttack)
			{
				base.creatureSFX.PlayOneShot(intimidateSFX);
				performedAmushAttack = true;
				SwitchToAttackSequence((base.enemyHP <= 3) ? 1 : 0);
			}
			break;
		}
		if (sync)
		{
			if (sentPlayerID == -1)
			{
				sentPlayerID = (int)GameNetworkManager.Instance.localPlayerController.playerClientId;
			}
			PlayAnimSFXServerRpc(switchCase, sentPlayerID);
		}
	}

	[ServerRpc(RequireOwnership = false)]
	private void PlayAnimSFXServerRpc(int switchCase, int sentPlayerID)
	{
		//IL_0024: Unknown result type (might be due to invalid IL or missing references)
		//IL_002e: Invalid comparison between Unknown and I4
		//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b0: Invalid comparison between Unknown and I4
		//IL_005f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0068: Unknown result type (might be due to invalid IL or missing references)
		//IL_006d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0071: Unknown result type (might be due to invalid IL or missing references)
		//IL_007e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0096: Unknown result type (might be due to invalid IL or missing references)
		NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
		if (networkManager != null && networkManager.IsListening)
		{
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				ServerRpcParams val = default(ServerRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(497655651u, val, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val2, switchCase);
				BytePacker.WriteValueBitPacked(val2, sentPlayerID);
				((NetworkBehaviour)this).__endSendServerRpc(ref val2, 497655651u, val, (RpcDelivery)0);
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				PlayAnimSFXClientRpc(switchCase, sentPlayerID);
			}
		}
	}

	[ClientRpc]
	private void PlayAnimSFXClientRpc(int switchCase, int sentPlayerID)
	{
		//IL_0024: Unknown result type (might be due to invalid IL or missing references)
		//IL_002e: Invalid comparison between Unknown and I4
		//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b0: Invalid comparison between Unknown and I4
		//IL_005f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0068: Unknown result type (might be due to invalid IL or missing references)
		//IL_006d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0071: Unknown result type (might be due to invalid IL or missing references)
		//IL_007e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0096: Unknown result type (might be due to invalid IL or missing references)
		NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
		if (networkManager != null && networkManager.IsListening)
		{
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 2 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val = default(ClientRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(500085956u, val, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val2, switchCase);
				BytePacker.WriteValueBitPacked(val2, sentPlayerID);
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 500085956u, val, (RpcDelivery)0);
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 2 && (networkManager.IsClient || networkManager.IsHost) && sentPlayerID != (int)GameNetworkManager.Instance.localPlayerController.playerClientId)
			{
				PlayAnimSFX(switchCase, sync: false);
			}
		}
	}

	public void SetAnimation(string trigger, int currentAttackOwner = -1)
	{
		if (((NetworkBehaviour)this).IsOwner)
		{
			if (currentAttackOwner == -1)
			{
				currentAttackOwner = currentAttackIndex;
			}
			base.creatureAnimator.SetTrigger(trigger);
			SetAnimationNonOwnerServerRpc(trigger, currentAttackOwner);
		}
	}

	[ServerRpc(RequireOwnership = false)]
	private void SetAnimationNonOwnerServerRpc(string trigger, int currentAttackOwner)
	{
		//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_00af: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
		NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
		if (networkManager == null || !networkManager.IsListening)
		{
			return;
		}
		if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
		{
			ServerRpcParams val = default(ServerRpcParams);
			FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(28236746u, val, (RpcDelivery)0);
			bool flag = trigger != null;
			((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
			if (flag)
			{
				((FastBufferWriter)(ref val2)).WriteValueSafe(trigger, false);
			}
			BytePacker.WriteValueBitPacked(val2, currentAttackOwner);
			((NetworkBehaviour)this).__endSendServerRpc(ref val2, 28236746u, val, (RpcDelivery)0);
		}
		if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
		{
			SetAnimationNonOwnerClientRpc(trigger, currentAttackOwner);
		}
	}

	[ClientRpc]
	private void SetAnimationNonOwnerClientRpc(string trigger, int currentAttackOwner)
	{
		//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_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 != 2 && (networkManager.IsServer || networkManager.IsHost))
		{
			ClientRpcParams val = default(ClientRpcParams);
			FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(2014096545u, val, (RpcDelivery)0);
			bool flag = trigger != null;
			((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
			if (flag)
			{
				((FastBufferWriter)(ref val2)).WriteValueSafe(trigger, false);
			}
			BytePacker.WriteValueBitPacked(val2, currentAttackOwner);
			((NetworkBehaviour)this).__endSendClientRpc(ref val2, 2014096545u, val, (RpcDelivery)0);
		}
		if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 2 && (networkManager.IsClient || networkManager.IsHost) && !((NetworkBehaviour)this).IsOwner)
		{
			currentAttackIndex = currentAttackOwner;
			base.creatureAnimator.SetTrigger(trigger);
		}
	}

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

	[RuntimeInitializeOnLoadMethod]
	internal static void InitializeRPCS_TestEnemyScript()
	{
		//IL_0011: Unknown result type (might be due to invalid IL or missing references)
		//IL_001b: Expected O, but got Unknown
		//IL_002c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0036: Expected O, but got Unknown
		//IL_0047: Unknown result type (might be due to invalid IL or missing references)
		//IL_0051: Expected O, but got Unknown
		//IL_0062: Unknown result type (might be due to invalid IL or missing references)
		//IL_006c: Expected O, but got Unknown
		//IL_007d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0087: Expected O, but got Unknown
		//IL_0098: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a2: Expected O, but got Unknown
		//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
		//IL_00bd: Expected O, but got Unknown
		//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d8: Expected O, but got Unknown
		//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f3: Expected O, but got Unknown
		//IL_0104: Unknown result type (might be due to invalid IL or missing references)
		//IL_010e: Expected O, but got Unknown
		//IL_011f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0129: Expected O, but got Unknown
		//IL_013a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0144: Expected O, but got Unknown
		NetworkManager.__rpc_func_table.Add(1280540858u, new RpcReceiveHandler(__rpc_handler_1280540858));
		NetworkManager.__rpc_func_table.Add(4112359130u, new RpcReceiveHandler(__rpc_handler_4112359130));
		NetworkManager.__rpc_func_table.Add(903098992u, new RpcReceiveHandler(__rpc_handler_903098992));
		NetworkManager.__rpc_func_table.Add(1207083148u, new RpcReceiveHandler(__rpc_handler_1207083148));
		NetworkManager.__rpc_func_table.Add(1404863536u, new RpcReceiveHandler(__rpc_handler_1404863536));
		NetworkManager.__rpc_func_table.Add(3380684369u, new RpcReceiveHandler(__rpc_handler_3380684369));
		NetworkManager.__rpc_func_table.Add(2785788926u, new RpcReceiveHandler(__rpc_handler_2785788926));
		NetworkManager.__rpc_func_table.Add(4019043694u, new RpcReceiveHandler(__rpc_handler_4019043694));
		NetworkManager.__rpc_func_table.Add(497655651u, new RpcReceiveHandler(__rpc_handler_497655651));
		NetworkManager.__rpc_func_table.Add(500085956u, new RpcReceiveHandler(__rpc_handler_500085956));
		NetworkManager.__rpc_func_table.Add(28236746u, new RpcReceiveHandler(__rpc_handler_28236746));
		NetworkManager.__rpc_func_table.Add(2014096545u, new RpcReceiveHandler(__rpc_handler_2014096545));
	}

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

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

	private static void __rpc_handler_903098992(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 playerID = default(int);
			ByteUnpacker.ReadValueBitPacked(reader, ref playerID);
			target.__rpc_exec_stage = (__RpcExecStage)1;
			((TestEnemyScript)(object)target).GiveShovelToPlayerServerRpc(playerID);
			target.__rpc_exec_stage = (__RpcExecStage)0;
		}
	}

	private static void __rpc_handler_1207083148(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 playerID = default(int);
			ByteUnpacker.ReadValueBitPacked(reader, ref playerID);
			target.__rpc_exec_stage = (__RpcExecStage)2;
			((TestEnemyScript)(object)target).GiveShovelToPlayerClientRpc(playerID);
			target.__rpc_exec_stage = (__RpcExecStage)0;
		}
	}

	private static void __rpc_handler_1404863536(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 playerID = default(int);
			ByteUnpacker.ReadValueBitPacked(reader, ref playerID);
			target.__rpc_exec_stage = (__RpcExecStage)1;
			((TestEnemyScript)(object)target).ChasePlayerServerRpc(playerID);
			target.__rpc_exec_stage = (__RpcExecStage)0;
		}
	}

	private static void __rpc_handler_3380684369(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 playerID = default(int);
			ByteUnpacker.ReadValueBitPacked(reader, ref playerID);
			target.__rpc_exec_stage = (__RpcExecStage)2;
			((TestEnemyScript)(object)target).ChasePlayerClientRpc(playerID);
			target.__rpc_exec_stage = (__RpcExecStage)0